test

Author: marioalexis84

src/Mod/Fem/App/FemPostFilter.cpp

@@ -68,26 +68,33 @@ FemPostFilter::FilterPipeline& FemPostFilter::getFilterPipeline(std::string name
 void FemPostFilter::setActiveFilterPipeline(std::string name)
 {
     if (m_activePipeline != name && isValid()) {
-
+        printf("aca3 %s\n", name.c_str());
         // disable all inputs of current pipeline
         if (m_activePipeline != "" and m_pipelines.find(m_activePipeline) != m_pipelines.end()) {
             m_pipelines[m_activePipeline].source->RemoveAllInputConnections(0);
+            printf("aca4 %s\n", name.c_str());
         }
 
         // handle the transform
         if (m_use_transform) {
             m_transform_filter->RemoveAllInputConnections(0);
             if (m_transform_location == TransformLocation::output) {
+                printf("aca5 %s\n", name.c_str());
                 m_transform_filter->SetInputConnection(m_pipelines[name].target->GetOutputPort(0));
+                printf("aca6 %s\n", name.c_str());
             }
             else {
+                printf("aca7 %s\n", name.c_str());
                 m_pipelines[name].source->SetInputConnection(m_transform_filter->GetOutputPort(0));
+                printf("aca8 %s\n", name.c_str());
             }
         }
 
         // set the new pipeline active
         m_activePipeline = name;
+        printf("aca9 %s\n", name.c_str());
         pipelineChanged();
+        printf("aca10 %s\n", name.c_str());
     }
 }
 
@@ -170,19 +177,34 @@ DocumentObjectExecReturn* FemPostFilter::execute()
 
     // the pipelines are setup correctly, all we need to do is to update and take out the data.
     if (!m_pipelines.empty() && !m_activePipeline.empty()) {
-        auto output = getFilterOutput();
 
-        if (output->GetNumberOfInputConnections(0) == 0) {
+        printf("filter execute -1\n");
+        auto output = getFilterOutput();
+        printf("filter execute 0 hasexecutive %d\n", output->HasExecutive());
+        if (output->GetNumberOfInputConnections(0) == 0 || !output->HasExecutive()) {
             return StdReturn;
         }
 
+        printf("filter execute 1\n");
         if (Frame.getValue() > 0) {
+            printf("filter execute 2\n");
             output->UpdateTimeStep(Frame.getValue());
+            printf("filter execute 3\n");
         }
         else {
+            printf("filter execute 4\n");
+            auto o = output->GetOutputDataObject(0);
+            int puntos = o->GetNumberOfElements(vtkDataObject::POINT);
+            int celdas = o->GetNumberOfElements(vtkDataObject::CELL);
+            printf("%s\tPUNTOS: %d\tCELLS: %d\n", m_activePipeline.c_str(), puntos, celdas);
+            //        if (puntos > 0) {
             output->Update();
+            printf("filter execute 5\n");
+            //        }
         }
+        printf("filter execute 6\n");
         Data.setValue(output->GetOutputDataObject(0));
+        printf("filter execute 7\n");
     }
 
     return StdReturn;
@@ -198,8 +220,13 @@ vtkSmartPointer<vtkDataSet> FemPostFilter::getInputData()
 
     vtkAlgorithmOutput* output = active.source->GetInputConnection(0, 0);
     vtkAlgorithm* algo = output->GetProducer();
+    printf("getInputData: %s\n", this->getNameInDocument());
+    auto o = algo->GetOutputDataObject(0);
+    int puntos = o->GetNumberOfElements(vtkDataObject::POINT);
+    // if (puntos > 0) {
     algo->Update();
-
+    //}
+    printf("getInputData2 PUNTOS: %d\n", puntos);
     return vtkDataSet::SafeDownCast(algo->GetOutputDataObject(0));
 }
 
@@ -722,27 +749,35 @@ FemPostSmoothFilterExtension::FemPostSmoothFilterExtension()
 
 void FemPostSmoothFilterExtension::extensionOnChanged(const App::Property* prop)
 {
+    printf("reco1\n");
     if (prop == &EnableSmoothing || prop == &Iterations) {
         // if disabled, set iterations to zero to do nothing
         m_smooth->SetNumberOfIterations(EnableSmoothing.getValue() ? Iterations.getValue() : 0);
+        printf("reco2\n");
     }
     else if (prop == &BoundarySmoothing) {
         m_smooth->SetBoundarySmoothing(static_cast<const App::PropertyBool*>(prop)->getValue());
+        printf("reco3\n");
     }
     else if (prop == &EdgeAngle) {
         m_smooth->SetEdgeAngle(static_cast<const App::PropertyAngle*>(prop)->getValue());
+        printf("reco4\n");
     }
     else if (prop == &FeatureAngle) {
         m_smooth->SetFeatureAngle(static_cast<const App::PropertyAngle*>(prop)->getValue());
+        printf("reco5\n");
     }
     else if (prop == &EdgeSmoothing) {
         m_smooth->SetFeatureEdgeSmoothing(static_cast<const App::PropertyBool*>(prop)->getValue());
+        printf("reco6\n");
     }
     else if (prop == &RelaxationFactor) {
         m_smooth->SetRelaxationFactor(static_cast<const App::PropertyFloat*>(prop)->getValue());
+        printf("reco7\n");
     }
     else {
         DocumentObjectExtension::extensionOnChanged(prop);
+        printf("reco8\n");
     }
 }
 
@@ -771,53 +806,66 @@ FemPostContoursFilter::FemPostContoursFilter()
     m_contourConstraints.StepSize = 1;
     NumberOfContours.setConstraints(&m_contourConstraints);
 
+    smoothExtension.initExtension(this);
+
     FilterPipeline contours;
     m_contours = vtkSmartPointer<vtkContourFilter>::New();
     m_contours->ComputeScalarsOn();
     smoothExtension.getFilter()->SetInputConnection(m_contours->GetOutputPort());
     contours.source = m_contours;
     contours.target = smoothExtension.getFilter();
     addFilterPipeline(contours, "contours");
+    printf("Aca\n");
     setActiveFilterPipeline("contours");
-
-    smoothExtension.initExtension(this);
+    printf("Aca2\n");
 }
 
 FemPostContoursFilter::~FemPostContoursFilter() = default;
 
 DocumentObjectExecReturn* FemPostContoursFilter::execute()
 {
+    printf("execute1\n");
     // update list of available fields and their vectors
     if (!m_blockPropertyChanges) {
+        printf("execute2\n");
         refreshFields();
+        printf("execute3\n");
         refreshVectors();
+        printf("execute4\n");
     }
 
     // recalculate the filter
     auto returnObject = Fem::FemPostFilter::execute();
 
     // delete contour field
     vtkDataSet* dset = getInputData();
+    printf("execute5\n");
     if (!dset) {
+        printf("execute6\n");
         return returnObject;
     }
     dset->GetPointData()->RemoveArray(contourFieldName.c_str());
     // refresh fields to reflect the deletion
     if (!m_blockPropertyChanges) {
+        printf("execute7\n");
         refreshFields();
+        printf("execute8\n");
     }
 
     return returnObject;
 }
 
 void FemPostContoursFilter::onChanged(const Property* prop)
 {
+    printf("cont1\n");
     if (m_blockPropertyChanges) {
         return;
     }
 
     if (prop == &Field && (Field.getValue() >= 0)) {
+        printf("cont2\n");
         refreshVectors();
+        printf("cont3\n");
     }
 
     // note that we need to calculate also in case of a Data change
@@ -828,23 +876,30 @@ void FemPostContoursFilter::onChanged(const Property* prop)
         double p[2];
 
         // get the field and its data
+        printf("cont4\n");
         vtkDataSet* dset = getInputData();
         if (!dset) {
             return;
         }
+        printf("throw2\n");
         vtkDataArray* pdata = dset->GetPointData()->GetArray(Field.getValueAsString());
+        printf("throw2\n");
         if (!pdata) {
             return;
         }
         if (pdata->GetNumberOfComponents() == 1) {
             // if we have a scalar, we can directly use the array
+            printf("cont5\n");
+            printf("throw3\n");
             m_contours->SetInputArrayToProcess(0,
                                                0,
                                                0,
                                                vtkDataObject::FIELD_ASSOCIATION_POINTS,
                                                Field.getValueAsString());
+            printf("throw3\n");
             pdata->GetRange(p);
             recalculateContours(p[0], p[1]);
+            printf("cont5\n");
         }
         else {
             // The contour filter handles vectors by taking always its first component.
@@ -862,11 +917,13 @@ void FemPostContoursFilter::onChanged(const Property* prop)
                 component = 2;
             }
             // extract the component to a new array
+            printf("cont6\n");
             vtkSmartPointer<vtkDoubleArray> componentArray = vtkSmartPointer<vtkDoubleArray>::New();
             componentArray->SetNumberOfComponents(1);
             vtkIdType numTuples = pdata->GetNumberOfTuples();
             componentArray->SetNumberOfTuples(numTuples);
 
+            printf("cont7\n");
             if (component >= 0) {
                 for (vtkIdType tupleIdx = 0; tupleIdx < numTuples; ++tupleIdx) {
                     componentArray->SetComponent(tupleIdx,
@@ -886,9 +943,11 @@ void FemPostContoursFilter::onChanged(const Property* prop)
                 }
             }
             // name the array
+            printf("cont8\n");
             contourFieldName = std::string(Field.getValueAsString()) + "_contour";
             componentArray->SetName(contourFieldName.c_str());
 
+            printf("cont9\n");
             // add the array as new field and use it for the contour filter
             dset->GetPointData()->AddArray(componentArray);
             m_contours->SetInputArrayToProcess(0,
@@ -897,27 +956,33 @@ void FemPostContoursFilter::onChanged(const Property* prop)
                                                vtkDataObject::FIELD_ASSOCIATION_POINTS,
                                                contourFieldName.c_str());
             componentArray->GetRange(p);
+            printf("cont10\n");
             recalculateContours(p[0], p[1]);
             if (prop == &Data) {
                 // we must recalculate to pass the new created contours field
                 // to ViewProviderFemPostObject
                 m_blockPropertyChanges = true;
                 execute();
                 m_blockPropertyChanges = false;
+                printf("cont11\n");
             }
         }
     }
+    printf("cont12\n");
 
     Fem::FemPostFilter::onChanged(prop);
 }
 
 short int FemPostContoursFilter::mustExecute() const
 {
+    printf("mustExtex1\n");
     if (Field.isTouched() || VectorMode.isTouched() || NumberOfContours.isTouched()
         || Data.isTouched()) {
+        printf("mustExtex2\n");
         return 1;
     }
     else {
+        printf("mustExtex3\n");
         return App::DocumentObject::mustExecute();
     }
 }
@@ -934,6 +999,7 @@ void FemPostContoursFilter::recalculateContours(double min, double max)
 void FemPostContoursFilter::refreshFields()
 {
     m_blockPropertyChanges = true;
+    printf("refresh1\n");
 
     std::string fieldName;
     if (Field.getValue() >= 0) {
@@ -957,26 +1023,32 @@ void FemPostContoursFilter::refreshFields()
     App::Enumeration empty;
     Field.setValue(empty);
     m_fields.setEnums(FieldsArray);
+    printf("throw5\n");
     Field.setValue(m_fields);
+    printf("throw5\n");
 
     // search if the current field is in the available ones and set it
     std::vector<std::string>::iterator it =
         std::find(FieldsArray.begin(), FieldsArray.end(), fieldName);
     if (!fieldName.empty() && it != FieldsArray.end()) {
         Field.setValue(fieldName.c_str());
     }
-    else {
+    else if (Field.isValid()) {
+        // select the first field if exist
         m_blockPropertyChanges = false;
-        // select the first field
+        printf("throw4\n");
         Field.setValue(long(0));
+        printf("throw4\n");
         fieldName = Field.getValueAsString();
     }
 
+    printf("refresh2\n");
     m_blockPropertyChanges = false;
 }
 
 void FemPostContoursFilter::refreshVectors()
 {
+    printf("refreshvec1\n");
     // refreshes the list of available vectors for the current Field
     m_blockPropertyChanges = true;
 
@@ -985,16 +1057,21 @@ void FemPostContoursFilter::refreshVectors()
         m_blockPropertyChanges = false;
         return;
     }
-    vtkDataArray* fieldArray = dset->GetPointData()->GetArray(Field.getValueAsString());
-    if (!fieldArray) {
+    vtkDataArray* fieldArray = nullptr;
+    if (Field.isValid()) {
+        fieldArray = dset->GetPointData()->GetArray(Field.getValueAsString());
+    }
+    else {
         m_blockPropertyChanges = false;
         return;
     }
 
     // store name if already set
     std::string vectorName;
     if (VectorMode.hasEnums() && VectorMode.getValue() >= 0) {
+        printf("throw1\n");
         vectorName = VectorMode.getValueAsString();
+        printf("throw1\n");
     }
 
     std::vector<std::string> vectorArray;
@@ -1022,6 +1099,7 @@ void FemPostContoursFilter::refreshVectors()
         VectorMode.setValue(vectorName.c_str());
     }
 
+    printf("refreshvec2\n");
     m_blockPropertyChanges = false;
 }
 

src/Mod/Fem/femtest/app/test_object.py

@@ -1123,13 +1123,16 @@ def create_all_fem_objects_doc(doc):
         vres = analysis.addObject(ObjectsFem.makePostVtkResult(doc, [res]))[0]
         ObjectsFem.makePostVtkFilterClipRegion(doc, vres)
         ObjectsFem.makePostVtkFilterClipScalar(doc, vres)
-        ObjectsFem.makePostVtkFilterContours(doc, vres)
+        print("TEST1")
+        #       ObjectsFem.makePostVtkFilterContours(doc, vres)
         ObjectsFem.makePostVtkFilterCutFunction(doc, vres)
         ObjectsFem.makePostVtkFilterWarp(doc, vres)
+        print("TEST2")
 
     analysis.addObject(ObjectsFem.makeSolverCalculiXCcxTools(doc))
     analysis.addObject(ObjectsFem.makeSolverCalculix(doc))
     sol = analysis.addObject(ObjectsFem.makeSolverElmer(doc))[0]
+    print("TEST3")
     analysis.addObject(ObjectsFem.makeSolverMystran(doc))
     analysis.addObject(ObjectsFem.makeSolverZ88(doc))
 
@@ -1144,6 +1147,8 @@ def create_all_fem_objects_doc(doc):
     ObjectsFem.makeEquationMagnetodynamic(doc, sol)
     ObjectsFem.makeEquationStaticCurrent(doc, sol)
 
+    print("TEST4")
     doc.recompute()
+    print("TEST5")
 
     return doc