NetworkLinkActor.cpp

Go to the documentation of this file.

/* This file is part of MODEL, the Mechanics Of Defect Evolution Library.
 *
 * Copyright (C) 2011 by Giacomo Po <gpo@ucla.edu>.
 *
 * model is distributed without any warranty under the
 * GNU General Public License (GPL) v2 <http://www.gnu.org/licenses/>.
 */
 
#ifndef model_NetworkLinkActor_cpp_
#define model_NetworkLinkActor_cpp_
 
#include <DislocationNetwork.h>
#include <numbers>
#include <map>
#include <iostream>
#include <deque>
#include <string>
 
#include <vtkVersion.h>
#include <vtkSmartPointer.h>
#include <vtkPolyData.h>
#include <vtkPolyDataMapper.h>
#include <vtkActor.h>
#include <vtkMath.h>
#include <vtkProperty.h>
#include <vtkTubeFilter.h>
#include <vtkPolyLine.h>
#include <vtkSphereSource.h>
#include <vtkArrowSource.h>
#include <vtkGlyph3D.h>
#include <vtkDoubleArray.h>
#include <vtkPointData.h>
#include <vtkLabeledDataMapper.h>
#include <vtkFloatArray.h>
#include <vtkTextProperty.h>
#include <vtkActor2D.h>
#include <vtkProperty2D.h>
#include <vtkRenderer.h>
#include <vtkLine.h>
#include <vtkCellData.h>
 
//#include <IDreader.h>
#include <DefectiveCrystal/DefectiveCrystalConfigIO.h>
#include <MeshPlane.h>
#include <NetworkLinkActor.h>
#include <Vector2Color.h>
 
#include <DDqtControls.h>
 
namespace model
{
 
    NetworkLinkActor::NetworkLinkActor(vtkGenericOpenGLRenderWindow* const renWin,vtkRenderer* const renderer,const DefectiveCrystal<3>& defectiveCrystal_in) :
    /* init */ renderWindow(renWin)
    /* init */,mainLayout(new QGridLayout(this))
    /* init */,showLinks(new QCheckBox(this))
    /* init */,sliderLinksRadius(new QSlider(this))
    /* init */,sliderNormalOpacity(new QSlider(Qt::Horizontal,this))
    /* init */,sliderZeroOpacity(new QSlider(Qt::Horizontal,this))
    /* init */,sliderBoundaryOpacity(new QSlider(Qt::Horizontal,this))
    /* init */,linksColorBox(new QComboBox(this))
    /* init */,clr(ColorScheme::colorBurgers)
    /* init */,polyData(vtkSmartPointer<vtkPolyData>::New())
    /* init */,polyDataBnd(vtkSmartPointer<vtkPolyData>::New())
    /* init */,polyData0(vtkSmartPointer<vtkPolyData>::New())
    /* init */,tubeFilter(vtkSmartPointer<vtkTubeFilter>::New())
    /* init */,tubeFilterBnd(vtkSmartPointer<vtkTubeFilter>::New())
    /* init */,tubeFilter0(vtkSmartPointer<vtkTubeFilter>::New())
    /* init */,tubeMapper(vtkSmartPointer<vtkPolyDataMapper>::New())
    /* init */,tubeActor(vtkSmartPointer<vtkActor>::New())
    /* init */,tubeMapperBnd(vtkSmartPointer<vtkPolyDataMapper>::New())
    /* init */,tubeActorBnd(vtkSmartPointer<vtkActor>::New())
    /* init */,tubeMapper0(vtkSmartPointer<vtkPolyDataMapper>::New())
    /* init */,tubeActor0(vtkSmartPointer<vtkActor>::New())
    /* init */,defectiveCrystal(defectiveCrystal_in)
    /* init */,dislocationNetwork(defectiveCrystal.template getUniqueTypedMicrostructure<DislocationNetwork<3>>())
    {
        showLinks->setObjectName("showSegments");
        showLinks->setChecked(true);
        showLinks->setText("links");
        sliderLinksRadius->setEnabled(true);
        sliderLinksRadius->setMinimum(0);
        sliderLinksRadius->setMaximum(30);
        sliderLinksRadius->setValue(5);
        sliderLinksRadius->setOrientation(Qt::Horizontal);
        
        sliderNormalOpacity->setObjectName("normalSegmentOpacity");
        sliderNormalOpacity->setRange(0,100);
        sliderNormalOpacity->setValue(100);
        sliderZeroOpacity->setObjectName("zeroBurgersOpacity");
        sliderBoundaryOpacity->setObjectName("boundarySegmentOpacity");
        for(auto* slider : {sliderZeroOpacity,sliderBoundaryOpacity})
        {
            slider->setRange(0,100);
            slider->setValue(0);
        }
        tubeActor0->SetVisibility(false);
        tubeActorBnd->SetVisibility(false);
        
        linksColorBox->addItem("Burgers vector");
        linksColorBox->addItem("plane normal");
        linksColorBox->addItem("glissile/sessile");
        linksColorBox->addItem("edge/screw");
        linksColorBox->addItem("slip system");
 
        auto *segmentsBox = controls::box("Segments", this, "Show or hide dislocation segments.", showLinks);
        controls::field(controls::grid(segmentsBox), 0, "Radius", sliderLinksRadius,
                        "Tube radius in simulation length units b. Changes apply immediately.");
        controls::field(
            controls::grid(segmentsBox), 1, "Coloring", linksColorBox,
            "Choose which dislocation property determines segment color. Slip system uses the SlipSystems palette.");
        controls::field(controls::grid(segmentsBox), 2, "Normal opacity", sliderNormalOpacity,
                        "Opacity of nonzero-Burgers segments away from external and grain boundaries. 0 is transparent; 100 is opaque.");
        controls::field(controls::grid(segmentsBox), 3, "Zero-Burgers opacity", sliderZeroOpacity,
                        "Opacity of segments with zero net Burgers vector, including those on boundaries. 0 is transparent; 100 is opaque.");
        controls::field(controls::grid(segmentsBox), 4, "Boundary/GB opacity", sliderBoundaryOpacity,
                        "Opacity of nonzero-Burgers segments on external boundaries or grain boundaries, including periodic grain boundaries. 0 is transparent; 100 is opaque.");
        mainLayout->addWidget(segmentsBox, 0, 0);
        mainLayout->setRowStretch(1, 1);
        this->setLayout(mainLayout);
        
        connect(showLinks,SIGNAL(stateChanged(int)), this, SLOT(modify()));
        connect(sliderNormalOpacity,SIGNAL(valueChanged(int)), this, SLOT(modify()));
        connect(sliderZeroOpacity,SIGNAL(valueChanged(int)), this, SLOT(modify()));
        connect(sliderBoundaryOpacity,SIGNAL(valueChanged(int)), this, SLOT(modify()));
        connect(sliderLinksRadius,SIGNAL(valueChanged(int)), this, SLOT(modify()));
        
        tubeFilter->SetInputData(polyData);
        tubeFilter->SetRadius(5.0); // this must be a function similar to setColor
        tubeFilter->SetNumberOfSides(10);
        tubeFilter->Update();
        tubeMapper->SetInputConnection(tubeFilter->GetOutputPort());
        tubeMapper->ScalarVisibilityOn();
        tubeMapper->SetScalarModeToUseCellFieldData();
        tubeMapper->SelectColorArray("Colors");
        tubeActor->SetMapper(tubeMapper);
        
        // Boundary segments
        tubeFilterBnd->SetInputData(polyDataBnd);
        tubeFilterBnd->SetRadius(5.0); // this must be a function similar to setColor
        tubeFilterBnd->SetNumberOfSides(10);
        tubeFilterBnd->Update();
        tubeMapperBnd->SetInputConnection(tubeFilterBnd->GetOutputPort());
        tubeMapperBnd->ScalarVisibilityOn();
        tubeActorBnd->SetMapper(tubeMapperBnd);
        tubeActorBnd->GetProperty()->SetOpacity(0.0); //(R,G,B)
        
        // Zero-Burgers Segments
        tubeFilter0->SetInputData(polyData0);
        tubeFilter0->SetRadius(5.0); // this must be a function similar to setColor
        tubeFilter0->SetNumberOfSides(10);
        tubeFilter0->Update();
        tubeMapper0->SetInputConnection(tubeFilter0->GetOutputPort());
        tubeMapper0->ScalarVisibilityOn();
        tubeActor0->SetMapper(tubeMapper0);
        tubeActor0->GetProperty()->SetColor(0.5, 0.5, 0.5); //(R,G,B)
        tubeActor0->GetProperty()->SetOpacity(0.0); //(R,G,B)
        
        renderer->AddActor(tubeActor);
        renderer->AddActor(tubeActorBnd);
        renderer->AddActor(tubeActor0);
    }
 
    void NetworkLinkActor::updateConfiguration(vtkPolyData* const nodePolyData,const SlipSystemTab::SlipSystemColorMapType& sscm )
    {// https://stackoverflow.com/questions/6878263/remove-individual-points-from-vtkpoints
        std::cout<<"Updating links..."<<std::flush;
        const auto t0= std::chrono::system_clock::now();
        if(dislocationNetwork)
        {
            vtkSmartPointer<vtkFloatArray> radii(vtkSmartPointer<vtkFloatArray>::New());
            vtkSmartPointer<vtkUnsignedCharArray> colors(vtkSmartPointer<vtkUnsignedCharArray>::New());
            vtkSmartPointer<vtkUnsignedCharArray> colorsBnd(vtkSmartPointer<vtkUnsignedCharArray>::New());
            radii->SetName("TubeRadius");
            colors->SetName("Colors");
            colorsBnd->SetNumberOfComponents(3);
            colors->SetNumberOfComponents(3);
            vtkSmartPointer<vtkCellArray> cells(vtkSmartPointer<vtkCellArray>::New());
            vtkSmartPointer<vtkCellArray> cellsBnd(vtkSmartPointer<vtkCellArray>::New());
            vtkSmartPointer<vtkCellArray> cells0(vtkSmartPointer<vtkCellArray>::New());
            
            // Match the network-node point ordering, rebuilding for every frame.
            std::map<size_t,vtkIdType> nodeIndices;
            for(const auto& entry : dislocationNetwork->networkNodes())
            {
                nodeIndices.emplace(entry.first,static_cast<vtkIdType>(nodeIndices.size()));
            }
 
            for (const auto& link : dislocationNetwork->networkLinks())
            {
                
                
 
                vtkSmartPointer<vtkLine> line(vtkSmartPointer<vtkLine>::New());
                line->GetPointIds()->SetId(0, nodeIndices.at(link.second.lock()->source->sID)); // the second 0 is the index of the Origin in linesPolyData's points
                line->GetPointIds()->SetId(1, nodeIndices.at(link.second.lock()->sink->sID));
                
                if(link.second.lock()->hasZeroBurgers())
                {
                    cells0->InsertNextCell(line);
                }
                else
                {
                    Eigen::Matrix<int,3,1> colorVector=computeColor(link.second.lock()->burgers(),link.second.lock()->chord(),link.second.lock()->slipSystem(),sscm);
                    unsigned char lineClr[3]={(unsigned char) colorVector(0),(unsigned char) colorVector(1),(unsigned char) colorVector(2)};
 
                    if(link.second.lock()->isGrainBoundarySegment() || link.second.lock()->isBoundarySegment())
                    {
                        cellsBnd->InsertNextCell(line);
                        colorsBnd->InsertNextTypedTuple(lineClr);
                    }
                    else
                    {
                        cells->InsertNextCell(line);
                        colors->InsertNextTypedTuple(lineClr);
                        radii->InsertNextValue(link.second.lock()->burgers().norm()*sliderLinksRadius->value());
                    }
                    
                    
//                    if(link.second.meshLocation!=0)
//                    {// 0=MeshLocation::insideMesh
//                        cellsBnd->InsertNextCell(line);
//                        //                        polyDataBnd->InsertNextCell(VTK_LINE,2,connectivity); //Connects the first and fourth point we inserted into a line
//                        colorsBnd->InsertNextTypedTuple(lineClr);
//                    }
//                    else
//                    {// internal segment
//                        //                        polyData->InsertNextCell(VTK_LINE,2,connectivity); //Connects the first and fourth point we inserted into a line
//                        cells->InsertNextCell(line);
//                        if(link.second.meshLocation==2 /*&& blackGrainBoundarySegments*/)
//                        {
//                            unsigned char lineClr1[3]={1,1,1};
//                            colors->InsertNextTypedTuple(lineClr1);
//                        }
//                        else
//                        {
//                            colors->InsertNextTypedTuple(lineClr);
//                        }
//                        
//                        radii->InsertNextValue(burgersNorm*sliderLinksRadius->value());
//                    }
                    
                }
 
                
//                auto itSource(configFields.configIO.nodeMap().find(link.second.sourceID)); //source
//                if(itSource!=configFields.configIO.nodeMap().end())
//                {
//                    auto   itSink(configFields.configIO.nodeMap().find(link.second.sinkID)); //sink
//                    if(itSink!=configFields.configIO.nodeMap().end())
//                    {
//                        vtkSmartPointer<vtkLine> line(vtkSmartPointer<vtkLine>::New());
//                        line->GetPointIds()->SetId(0, std::distance(configFields.configIO.nodeMap().begin(),itSource)); // the second 0 is the index of the Origin in linesPolyData's points
//                        line->GetPointIds()->SetId(1, std::distance(configFields.configIO.nodeMap().begin(),itSink));
//                        
//                        const auto chord(configFields.configIO.nodes()[itSink->second].P-configFields.configIO.nodes()[itSource->second].P);
//                        const double burgersNorm(link.second.b.norm());
//                        if(burgersNorm>FLT_EPSILON)
//                        {
//                            Eigen::Matrix<int,3,1> colorVector=computeColor(link.second.b,chord,link.second.n);
//                            unsigned char lineClr[3]={(unsigned char) colorVector(0),(unsigned char) colorVector(1),(unsigned char) colorVector(2)};
//                            
//                            if(link.second.meshLocation!=0)
//                            {// 0=MeshLocation::insideMesh
//                                cellsBnd->InsertNextCell(line);
//                                //                        polyDataBnd->InsertNextCell(VTK_LINE,2,connectivity); //Connects the first and fourth point we inserted into a line
//                                colorsBnd->InsertNextTypedTuple(lineClr);
//                            }
//                            else
//                            {
//                                //                        polyData->InsertNextCell(VTK_LINE,2,connectivity); //Connects the first and fourth point we inserted into a line
//                                cells->InsertNextCell(line);
//                                if(link.second.meshLocation==2 /*&& blackGrainBoundarySegments*/)
//                                {
//                                    unsigned char lineClr1[3]={1,1,1};
//                                    colors->InsertNextTypedTuple(lineClr1);
//                                }
//                                else
//                                {
//                                    colors->InsertNextTypedTuple(lineClr);
//                                }
//                                
//                                radii->InsertNextValue(burgersNorm*sliderLinksRadius->value());
//                            }
//                        }
//                        else
//                        {
//                            cells0->InsertNextCell(line);
//                            //                    polyData0->InsertNextCell(VTK_LINE,2,connectivity); //Connects the first and fourth point we inserted into a line
//                        }
//                    }
//                    else
//                    {
//                        throw std::runtime_error("SINK VERTEX NOT FOUND IN nodeMap");
//                    }
//                }
//                else
//                {
//                    throw std::runtime_error("SOURCE VERTEX NOT FOUND IN nodeMap");
//                }
            }
            
            polyData->SetPoints(nodePolyData->GetPoints());
            polyData->SetLines(cells);
            polyData->GetCellData()->AddArray(colors);
            polyData->GetPointData()->AddArray(radii);
            polyData->GetPointData()->SetActiveScalars("TubeRadius");
            polyData->Modified();
            
            polyDataBnd->SetPoints(nodePolyData->GetPoints());
            polyDataBnd->SetLines(cellsBnd);
            polyDataBnd->GetCellData()->SetScalars(colorsBnd);
            polyDataBnd->Modified();
            
            polyData0->SetPoints(nodePolyData->GetPoints());
            polyData0->SetLines(cells0);
            polyData0->Modified();
        }
        std::cout<<magentaColor<<" ["<<(std::chrono::duration<double>(std::chrono::system_clock::now()-t0)).count()<<" sec]"<<defaultColor<<std::endl;
    }
 
    /**********************************************************************/
    void NetworkLinkActor::modify()
    {
        sliderLinksRadius->setEnabled(showLinks->isChecked());
        tubeActor->SetVisibility(showLinks->isChecked() && sliderNormalOpacity->value()>0);
        tubeActor->GetProperty()->SetOpacity(sliderNormalOpacity->value()/100.0);
        tubeActorBnd->SetVisibility(showLinks->isChecked() && sliderBoundaryOpacity->value()>0);
        tubeActorBnd->GetProperty()->SetOpacity(sliderBoundaryOpacity->value()/100.0);
        tubeActor0->GetProperty()->SetOpacity(sliderZeroOpacity->value()/100.0);
        linksColorBox->setEnabled(showLinks->isChecked());
        tubeActor0->SetVisibility(showLinks->isChecked() && sliderZeroOpacity->value()>0);
        tubeFilter->SetRadius(sliderLinksRadius->value()); // this must be a function similar to setColor
        tubeFilterBnd->SetRadius(sliderLinksRadius->value()); // this must be a function similar to setColor
        tubeFilter0->SetRadius(sliderLinksRadius->value()); // this must be a function similar to setColor
        if(renderWindow->GetReadyForRendering())
        {
            renderWindow->Render();
        }
    }
 
//    Eigen::Matrix<int,3,1> NetworkLinkActor::vector2Clr(VectorDim clrVector) const
//    {
//        float clrTol=100.0*FLT_EPSILON;
//        if(clrVector(0)<-clrTol)
//        {// first component not zero but begative, flip color
//            clrVector*=-1.0;
//        }
//        else if(fabs(clrVector(0))<=clrTol)
//        {// first component is zero, use second component
//            if(clrVector(1)<-clrTol)
//            {// second component not zero but begative, flip color
//                clrVector*=-1.0;
//            }
//            else if(fabs(clrVector(1))<=clrTol)
//            {// second component is zero, use third component
//                if(clrVector(2)<-clrTol)
//                {
//                    clrVector*=-1.0;
//                }
//            }
//        }
//        
//        clrVector = (clrVector + VectorDim::Ones(dim) * clrVector.norm()).eval();
//        clrVector.normalize();
//        return (clrVector*255).cast<int>();
//    }
 
    /*********************************************************************/
    Eigen::Matrix<int,3,1> NetworkLinkActor::computeColor(const VectorDim& burgers, const VectorDim& chord, const std::shared_ptr<SlipSystem>& slipSystem,const SlipSystemTab::SlipSystemColorMapType& sscm) const
    {
        
        VectorDim clrVector(VectorDim::Zero());
        
        
        
        switch (linksColorBox->currentIndex())
        {
                
            default:
            {
                clrVector = burgers.normalized();
                //                    flipColor(colorVector);
                break;
            }
                
            case 1:
            {
                if(slipSystem)
                {
                    clrVector=slipSystem->unitNormal;
                }
                break;
            }
                
            case 2:
            {
//                const bool isSessile= planeNormal.squaredNorm()<FLT_EPSILON || fabs(burgers.dot(planeNormal))>FLT_EPSILON;
//                const bool isSessile((slipSystem));
                clrVector(0)= slipSystem? 1.0 : 0.1;
                clrVector(1)= slipSystem? 0.5 : 0.4;
                clrVector(2)= slipSystem? 0.0 : 0.9;
                break;
            }
                
            case 3:
            {
                const float u = acos(std::fabs(chord.normalized().dot(burgers.normalized())))*2.0/std::numbers::pi;
                //                            RGBcolor rgb(RGBmap::getColor(std::fabs(tubeTangents.col(k).normalized().dot(burgers.normalized())),0,1));
                //                            colorVector << rgb.r, rgb.g, rgb.b;
//                clrVector=(VectorDim()<<1.0,0.647,0.0).finished()*u+VectorDim::UnitZ()*(1.0-u);
                clrVector=VectorDim::UnitX()*u+VectorDim::UnitZ()*(1.0-u);
                break;
            }
                
            case 4:
            {
                clrVector=VectorDim::Zero();
                
                if(slipSystem)
                {
                    const auto ssIter(sscm.find(slipSystem.get()));
                    if(ssIter!=sscm.end())
                    {
                        clrVector=ssIter->second->rgb().template cast<double>()/255.0;
                    }
                }
                break;
            }
                //                    break;
                
        }
        
        return Vector2Color::v2c(clrVector);
    }
 
 
} // namespace model
#endif