ForkMaster/smesh
1
0
Fork 0
mirror of https://git.salome-platform.org/gitpub/modules/smesh.git synced 2024-12-26 09:20:34 +05:00
Code Issues Packages Projects Releases Wiki Activity

23422: EDF 14312 - Strange behavior of Viscous Layer Surface offset + smooth

Browse Source 
+ Extract Morph from StdMeshers_Projection_2D.cxx

+ Fix formatting in SMESH_ScalarBarActor.cxx
This commit is contained in:
eap 2017-04-11 19:40:35 +03:00
parent d1bb1f5d44
commit c150e1e4c4
8 changed files with 1109 additions and 673 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
doc/salome/gui/SMESH/input/smeshpy_interface.doc
View File

@ -2,10 +2,10 @@
\page smeshpy_interface_page Python interface
Python API for SALOME %Mesh module defines several classes that can
Python API of SALOME %Mesh module defines several classes that can
be used for easy mesh creation and edition.
Documentation for SALOME %Mesh module Python API is available in two forms:
Documentation of SALOME %Mesh module Python API is available in two forms:
- <a href="smeshpy_doc/modules.html">Structured documentation</a>, where all methods and
classes are grouped by their functionality.
- <a href="smeshpy_doc/namespaces.html">Linear documentation</a> grouped only by classes, declared

388
src/OBJECT/SMESH_ScalarBarActor.cxx
View File

@ -28,16 +28,16 @@
#include <vtkCellArray.h>
#include <vtkCellData.h>
#include <vtkLookupTable.h>
#include <vtkObjectFactory.h>
#include <vtkPolyData.h>
#include <vtkPolyDataMapper2D.h>
#include <vtkProperty2D.h>
#include <vtkScalarsToColors.h>
#include <vtkTextMapper.h>
#include <vtkTextProperty.h>
#include <vtkViewport.h>
#include <vtkWindow.h>
#include <vtkLookupTable.h>
#include <vtkProperty2D.h>
#define SHRINK_COEF 0.08;
@ -51,7 +51,8 @@ vtkCxxSetObjectMacro(SMESH_ScalarBarActor,TitleTextProperty,vtkTextProperty);
// Instantiate object with 64 maximum colors; 5 labels; %%-#6.3g label
// format, no title, and vertical orientation. The initial scalar bar
// size is (0.05 x 0.8) of the viewport size.
SMESH_ScalarBarActor::SMESH_ScalarBarActor() {
SMESH_ScalarBarActor::SMESH_ScalarBarActor()
{
this->LookupTable = NULL;
this->Position2Coordinate->SetValue(0.17, 0.8);
@ -129,12 +130,12 @@ void SMESH_ScalarBarActor::ReleaseGraphicsResources(vtkWindow *win)
{
this->TitleActor->ReleaseGraphicsResources(win);
if (this->TextMappers != NULL )
{
{
for (int i=0; i < this->NumberOfLabelsBuilt; i++)
{
{
this->TextActors[i]->ReleaseGraphicsResources(win);
}
}
}
this->ScalarBarActor->ReleaseGraphicsResources(win);
// rnv begin
// Customization of the vtkScalarBarActor to show distribution histogram.
@ -143,36 +144,37 @@ void SMESH_ScalarBarActor::ReleaseGraphicsResources(vtkWindow *win)
/*--------------------------------------------------------------------------*/
SMESH_ScalarBarActor::~SMESH_ScalarBarActor() {
SMESH_ScalarBarActor::~SMESH_ScalarBarActor()
{
if (this->LabelFormat)
{
{
delete [] this->LabelFormat;
this->LabelFormat = NULL;
}
}
this->TitleMapper->Delete();
this->TitleActor->Delete();
if (this->TextMappers != NULL )
{
{
for (int i=0; i < this->NumberOfLabelsBuilt; i++)
{
{
this->TextMappers[i]->Delete();
this->TextActors[i]->Delete();
}
}
delete [] this->TextMappers;
delete [] this->TextActors;
}
}
this->ScalarBar->Delete();
this->ScalarBarMapper->Delete();
this->ScalarBarActor->Delete();
if (this->Title)
{
{
delete [] this->Title;
this->Title = NULL;
}
}
this->SetLookupTable(NULL);
this->SetLabelTextProperty(NULL);
@ -194,22 +196,22 @@ int SMESH_ScalarBarActor::RenderOverlay(vtkViewport *viewport)
// Everything is built, just have to render
if (this->Title != NULL)
{
{
renderedSomething += this->TitleActor->RenderOverlay(viewport);
}
if (!myTitleOnlyVisibility) {
}
if ( !myTitleOnlyVisibility ) {
this->ScalarBarActor->RenderOverlay(viewport);
this->myDistributionActor->RenderOverlay(viewport);
if( this->TextActors == NULL)
{
vtkWarningMacro(<<"Need a mapper to render a scalar bar");
return renderedSomething;
}
if ( this->TextActors == NULL )
{
vtkWarningMacro(<<"Need a mapper to render a scalar bar");
return renderedSomething;
}
for (i=0; i<this->NumberOfLabels; i++)
{
for ( i=0; i<this->NumberOfLabels; i++ )
{
renderedSomething += this->TextActors[i]->RenderOverlay(viewport);
}
}
}
renderedSomething = (renderedSomething > 0)?(1):(0);
@ -225,29 +227,29 @@ int SMESH_ScalarBarActor::RenderOpaqueGeometry(vtkViewport *viewport)
int size[2];
if (!this->LookupTable)
{
{
vtkWarningMacro(<<"Need a mapper to render a scalar bar");
return 0;
}
}
if (!this->TitleTextProperty)
{
{
vtkErrorMacro(<<"Need title text property to render a scalar bar");
return 0;
}
}
if (!this->LabelTextProperty)
{
{
vtkErrorMacro(<<"Need label text property to render a scalar bar");
return 0;
}
}
// Check to see whether we have to rebuild everything
int positionsHaveChanged = 0;
if (viewport->GetMTime() > this->BuildTime ||
(viewport->GetVTKWindow() &&
viewport->GetVTKWindow()->GetMTime() > this->BuildTime))
{
{
// if the viewport has changed we may - or may not need
// to rebuild, it depends on if the projected coords chage
int *barOrigin;
@ -262,32 +264,32 @@ int SMESH_ScalarBarActor::RenderOpaqueGeometry(vtkViewport *viewport)
this->LastSize[1] != size[1] ||
this->LastOrigin[0] != barOrigin[0] ||
this->LastOrigin[1] != barOrigin[1])
{
{
positionsHaveChanged = 1;
}
}
}
// Check to see whether we have to rebuild everything
if (positionsHaveChanged ||
this->GetMTime() > this->BuildTime ||
this->LookupTable->GetMTime() > this->BuildTime ||
this->LabelTextProperty->GetMTime() > this->BuildTime ||
this->TitleTextProperty->GetMTime() > this->BuildTime)
{
if ( positionsHaveChanged ||
this->GetMTime() > this->BuildTime ||
this->LookupTable->GetMTime() > this->BuildTime ||
this->LabelTextProperty->GetMTime() > this->BuildTime ||
this->TitleTextProperty->GetMTime() > this->BuildTime)
{
vtkDebugMacro(<<"Rebuilding subobjects");
// Delete previously constructed objects
//
if (this->TextMappers != NULL )
if ( this->TextMappers != NULL )
{
for ( i = 0; i < this->NumberOfLabelsBuilt; i++ )
{
for (i=0; i < this->NumberOfLabelsBuilt; i++)
{
this->TextMappers[i]->Delete();
this->TextActors[i]->Delete();
}
}
delete [] this->TextMappers;
delete [] this->TextActors;
}
}
// Build scalar bar object; determine its type
//
@ -300,12 +302,12 @@ int SMESH_ScalarBarActor::RenderOpaqueGeometry(vtkViewport *viewport)
vtkLookupTable *LUT = vtkLookupTable::SafeDownCast( this->LookupTable );
int isLogTable = 0;
if ( LUT )
{
{
if ( LUT->GetScale() == VTK_SCALE_LOG10 )
{
{
isLogTable = 1;
}
}
}
// we hard code how many steps to display
vtkScalarsToColors *lut = this->LookupTable;
@ -332,7 +334,8 @@ int SMESH_ScalarBarActor::RenderOpaqueGeometry(vtkViewport *viewport)
if(!distrVisibility)
vtkDebugMacro(<<" Distribution invisible, because numColors == this->myNbValues.size()");
if ( distrVisibility && GetDistributionVisibility() ) {
if ( distrVisibility && GetDistributionVisibility() )
{
for ( i = 0 ; i < (int)myNbValues.size(); i++ ) {
if ( myNbValues[i] ) {
numPositiveVal++;
@ -349,16 +352,21 @@ int SMESH_ScalarBarActor::RenderOpaqueGeometry(vtkViewport *viewport)
this->myDistribution->SetPolys(distrPolys);
distrPts->Delete();
distrPolys->Delete();
if ( myDistributionColoringType == SMESH_MULTICOLOR_TYPE ) {
if ( myDistributionColoringType == SMESH_MULTICOLOR_TYPE )
{
distColors = vtkUnsignedCharArray::New();
distColors->SetNumberOfComponents(3);
distColors->SetNumberOfTuples(numPositiveVal);
this->myDistribution->GetCellData()->SetScalars(distColors);
distColors->Delete();
} else if( myDistributionColoringType == SMESH_MONOCOLOR_TYPE ){
}
else if( myDistributionColoringType == SMESH_MONOCOLOR_TYPE )
{
this->myDistribution->GetCellData()->SetScalars(NULL);
}
} else {
}
else
{
myDistribution->Reset();
}
// rnv end
@ -388,7 +396,7 @@ int SMESH_ScalarBarActor::RenderOpaqueGeometry(vtkViewport *viewport)
this->TitleActor->SetProperty(this->GetProperty());
this->TitleMapper->SetInput(this->Title);
if (this->TitleTextProperty->GetMTime() > this->BuildTime)
{
{
// Shallow copy here so that the size of the title prop is not affected
// by the automatic adjustment of its text mapper's size (i.e. its
// mapper's text property is identical except for the font size
@ -397,7 +405,7 @@ int SMESH_ScalarBarActor::RenderOpaqueGeometry(vtkViewport *viewport)
// the title and label text prop to be the same.
this->TitleMapper->GetTextProperty()->ShallowCopy(this->TitleTextProperty);
this->TitleMapper->GetTextProperty()->SetJustificationToCentered();
}
}
// find the best size for the title font
int titleSize[2];
@ -435,13 +443,13 @@ int SMESH_ScalarBarActor::RenderOpaqueGeometry(vtkViewport *viewport)
pts->SetPoint(2*i+1,x);
}
if(GetDistributionVisibility() && distrVisibility) {
if ( GetDistributionVisibility() && distrVisibility ) {
// Distribution points
shrink = delta*SHRINK_COEF;
vtkIdType distPtsId=0;
vtkIdType distPtsIds[4];
for(i=0; i<numColors; i++) {
if(myNbValues[i]) {
for ( i = 0; i < numColors; i++ ) {
if ( myNbValues[i] ) {
itemH = distrHeight*((double)myNbValues[i]/maxValue);
if(distrHeight == itemH)
@ -484,7 +492,7 @@ int SMESH_ScalarBarActor::RenderOpaqueGeometry(vtkViewport *viewport)
// rnv begin
// Customization of the vtkScalarBarActor to show distribution histogram.
double coef1, delimeter=0.0;
if(GetDistributionVisibility() && distrVisibility) {
if ( GetDistributionVisibility() && distrVisibility ) {
coef1=0.62;
distrHeight = (int)((coef1/2)*size[1]);
//delimeter between distribution diagram and scalar bar
@ -499,7 +507,7 @@ int SMESH_ScalarBarActor::RenderOpaqueGeometry(vtkViewport *viewport)
barHeight = (int)(coef1*size[1]);
delta=(double)barWidth/numColors;
for (i=0; i<numPts/2; i++) {
for ( i = 0; i < numPts/2; i++ ) {
x[0] = i*delta;
x[1] = barHeight;
pts->SetPoint(2*i,x);
@ -507,12 +515,12 @@ int SMESH_ScalarBarActor::RenderOpaqueGeometry(vtkViewport *viewport)
pts->SetPoint(2*i+1,x);
}
if(GetDistributionVisibility() && distrVisibility) {
if ( GetDistributionVisibility() && distrVisibility ) {
// Distribution points
shrink = delta*SHRINK_COEF;
vtkIdType distPtsId=0;
vtkIdType distPtsIds[4];
for(i=0; i<numColors; i++) {
for ( i = 0; i < numColors; i++ ) {
if(myNbValues[i]) {
itemH = distrHeight*((double)myNbValues[i]/maxValue);
@ -551,8 +559,8 @@ int SMESH_ScalarBarActor::RenderOpaqueGeometry(vtkViewport *viewport)
//polygons & cell colors
unsigned char *rgba, *rgb;
vtkIdType ptIds[4], dcCount=0;
for (i=0; i<numColors; i++)
{
for ( i = 0; i < numColors; i++ )
{
ptIds[0] = 2*i;
ptIds[1] = ptIds[0] + 1;
ptIds[2] = ptIds[1] + 2;
@ -560,16 +568,16 @@ int SMESH_ScalarBarActor::RenderOpaqueGeometry(vtkViewport *viewport)
polys->InsertNextCell(4,ptIds);
if ( isLogTable )
{
{
double rgbval = log10(range[0]) +
i*(log10(range[1])-log10(range[0]))/(numColors -1);
rgba = lut->MapValue(pow(10.0,rgbval));
}
}
else
{
{
rgba = lut->MapValue(range[0] + (range[1] - range[0])*
((double)i /(numColors-1.0)));
}
}
rgb = colors->GetPointer(3*i); //write into array directly
rgb[0] = rgba[0];
@ -578,75 +586,77 @@ int SMESH_ScalarBarActor::RenderOpaqueGeometry(vtkViewport *viewport)
// rnv begin
// Customization of the vtkScalarBarActor to show distribution histogram.
if(myDistributionColoringType == SMESH_MULTICOLOR_TYPE && GetDistributionVisibility() && distrVisibility)
{
rgb = distColors->GetPointer(3*dcCount); //write into array directly
rgb[0] = rgba[0];
rgb[1] = rgba[1];
rgb[2] = rgba[2];
dcCount++;
}
if ( myDistributionColoringType == SMESH_MULTICOLOR_TYPE &&
GetDistributionVisibility() &&
distrVisibility )
{
rgb = distColors->GetPointer(3*dcCount); //write into array directly
rgb[0] = rgba[0];
rgb[1] = rgba[1];
rgb[2] = rgba[2];
dcCount++;
}
}
// Now position everything properly
//
double val;
if (this->Orientation == VTK_ORIENT_VERTICAL)
{
if ( this->Orientation == VTK_ORIENT_VERTICAL )
{
int sizeTextData[2];
// center the title
this->TitleActor->SetPosition(size[0]/2, 0.9*size[1]);
for (i=0; i < this->NumberOfLabels; i++)
for ( i = 0; i < this->NumberOfLabels; i++ )
{
if ( this->NumberOfLabels > 1 )
{
if (this->NumberOfLabels > 1)
{
val = (double)i/(this->NumberOfLabels-1) *barHeight;
}
}
else
{
{
val = 0.5*barHeight;
}
}
this->TextMappers[i]->GetSize(viewport,sizeTextData);
this->TextMappers[i]->GetTextProperty()->SetJustificationToLeft();
this->TextActors[i]->SetPosition(barWidth+3,
val - sizeTextData[1]/2);
}
}
}
else
{
{
this->TitleActor->SetPosition(size[0]/2,
barHeight + labelSize[1] + 0.1*size[1]);
for (i=0; i < this->NumberOfLabels; i++)
{
for ( i = 0; i < this->NumberOfLabels; i++ )
{
this->TextMappers[i]->GetTextProperty()->SetJustificationToCentered();
if (this->NumberOfLabels > 1)
{
{
val = (double)i/(this->NumberOfLabels-1) * barWidth;
}
else
{
val = 0.5*barWidth;
}
this->TextActors[i]->SetPosition(val, barHeight + 0.05*size[1]);
}
else
{
val = 0.5*barWidth;
}
this->TextActors[i]->SetPosition(val, barHeight + 0.05*size[1]);
}
}
this->BuildTime.Modified();
}
}
// Everything is built, just have to render
if (this->Title != NULL)
{
if ( this->Title != NULL )
{
renderedSomething += this->TitleActor->RenderOpaqueGeometry(viewport);
}
}
this->ScalarBarActor->RenderOpaqueGeometry(viewport);
this->myDistributionActor->RenderOpaqueGeometry(viewport);
for (i=0; i<this->NumberOfLabels; i++)
{
for ( i = 0; i < this->NumberOfLabels; i++ )
{
renderedSomething += this->TextActors[i]->RenderOpaqueGeometry(viewport);
}
}
renderedSomething = (renderedSomething > 0)?(1):(0);
@ -659,34 +669,34 @@ void SMESH_ScalarBarActor::PrintSelf(ostream& os, vtkIndent indent)
this->Superclass::PrintSelf(os,indent);
if ( this->LookupTable )
{
{
os << indent << "Lookup Table:\n";
this->LookupTable->PrintSelf(os,indent.GetNextIndent());
}
}
else
{
{
os << indent << "Lookup Table: (none)\n";
}
}
if (this->TitleTextProperty)
{
{
os << indent << "Title Text Property:\n";
this->TitleTextProperty->PrintSelf(os,indent.GetNextIndent());
}
}
else
{
{
os << indent << "Title Text Property: (none)\n";
}
}
if (this->LabelTextProperty)
{
{
os << indent << "Label Text Property:\n";
this->LabelTextProperty->PrintSelf(os,indent.GetNextIndent());
}
}
else
{
{
os << indent << "Label Text Property: (none)\n";
}
}
os << indent << "Title: " << (this->Title ? this->Title : "(none)") << "\n";
os << indent << "Maximum Number Of Colors: "
@ -696,13 +706,13 @@ void SMESH_ScalarBarActor::PrintSelf(ostream& os, vtkIndent indent)
os << indent << "Orientation: ";
if ( this->Orientation == VTK_ORIENT_HORIZONTAL )
{
{
os << "Horizontal\n";
}
}
else
{
{
os << "Vertical\n";
}
}
os << indent << "Label Format: " << this->LabelFormat << "\n";
}
@ -712,7 +722,7 @@ void SMESH_ScalarBarActor::ShallowCopy(vtkProp *prop)
{
SMESH_ScalarBarActor *a = SMESH_ScalarBarActor::SafeDownCast(prop);
if ( a != NULL )
{
{
this->SetPosition2(a->GetPosition2());
this->SetLookupTable(a->GetLookupTable());
this->SetMaximumNumberOfColors(a->GetMaximumNumberOfColors());
@ -721,25 +731,25 @@ void SMESH_ScalarBarActor::ShallowCopy(vtkProp *prop)
this->SetTitleTextProperty(a->GetTitleTextProperty());
this->SetLabelFormat(a->GetLabelFormat());
this->SetTitle(a->GetTitle());
this->GetPositionCoordinate()->SetCoordinateSystem(
a->GetPositionCoordinate()->GetCoordinateSystem());
this->GetPositionCoordinate()->SetValue(
a->GetPositionCoordinate()->GetValue());
this->GetPosition2Coordinate()->SetCoordinateSystem(
a->GetPosition2Coordinate()->GetCoordinateSystem());
this->GetPosition2Coordinate()->SetValue(
a->GetPosition2Coordinate()->GetValue());
}
this->GetPositionCoordinate()->SetCoordinateSystem
(a->GetPositionCoordinate()->GetCoordinateSystem());
this->GetPositionCoordinate()->SetValue
(a->GetPositionCoordinate()->GetValue());
this->GetPosition2Coordinate()->SetCoordinateSystem
(a->GetPosition2Coordinate()->GetCoordinateSystem());
this->GetPosition2Coordinate()->SetValue
(a->GetPosition2Coordinate()->GetValue());
}
// Now do superclass
this->vtkActor2D::ShallowCopy(prop);
}
//----------------------------------------------------------------------------
void SMESH_ScalarBarActor::AllocateAndSizeLabels(int *labelSize,
int *size,
vtkViewport *viewport,
double *range)
void SMESH_ScalarBarActor::AllocateAndSizeLabels(int *labelSize,
int *size,
vtkViewport *viewport,
double *range)
{
labelSize[0] = labelSize[1] = 0;
@ -762,43 +772,43 @@ void SMESH_ScalarBarActor::AllocateAndSizeLabels(int *labelSize,
vtkLookupTable *LUT = vtkLookupTable::SafeDownCast( this->LookupTable );
int isLogTable = 0;
if ( LUT )
{
{
if ( LUT->GetScale() == VTK_SCALE_LOG10 )
{
isLogTable = 1;
}
}
for (i=0; i < this->NumberOfLabels; i++)
{
isLogTable = 1;
}
}
for ( i = 0; i < this->NumberOfLabels; i++ )
{
this->TextMappers[i] = vtkTextMapper::New();
if ( isLogTable )
{
{
double lval;
if (this->NumberOfLabels > 1)
{
if ( this->NumberOfLabels > 1 )
{
lval = log10(range[0]) + (double)i/(this->NumberOfLabels-1) *
(log10(range[1])-log10(range[0]));
}
else
{
lval = log10(range[0]) + 0.5*(log10(range[1])-log10(range[0]));
}
val = pow(10.0,lval);
}
else
else
{
lval = log10(range[0]) + 0.5*(log10(range[1])-log10(range[0]));
}
val = pow(10.0,lval);
}
else
{
if ( this->NumberOfLabels > 1 )
{
if (this->NumberOfLabels > 1)
{
val = range[0] +
(double)i/(this->NumberOfLabels-1) * (range[1]-range[0]);
}
else
{
val = range[0] + 0.5*(range[1]-range[0]);
}
}
else
{
val = range[0] + 0.5*(range[1]-range[0]);
}
}
sprintf(string, this->LabelFormat, val);
this->TextMappers[i]->SetInput(string);
@ -809,64 +819,63 @@ void SMESH_ScalarBarActor::AllocateAndSizeLabels(int *labelSize,
// which will be modified later). This allows text actors to
// share the same text property, and in that case specifically allows
// the title and label text prop to be the same.
this->TextMappers[i]->GetTextProperty()->ShallowCopy(
this->LabelTextProperty);
this->TextMappers[i]->GetTextProperty()->ShallowCopy(this->LabelTextProperty);
this->TextActors[i] = vtkActor2D::New();
this->TextActors[i]->SetMapper(this->TextMappers[i]);
this->TextActors[i]->SetProperty(this->GetProperty());
this->TextActors[i]->GetPositionCoordinate()->
SetReferenceCoordinate(this->PositionCoordinate);
}
}
if (this->NumberOfLabels)
{
if ( this->NumberOfLabels )
{
int targetWidth, targetHeight;
// rnv begin
// Customization of the vtkScalarBarActor to show distribution histogram.
bool distrVisibility = ( this->MaximumNumberOfColors == (int) this->myNbValues.size() );
double coef;
if( GetDistributionVisibility() && distrVisibility )
if(this->Orientation == VTK_ORIENT_VERTICAL)
if ( GetDistributionVisibility() && distrVisibility )
if ( this->Orientation == VTK_ORIENT_VERTICAL )
coef = 0.4;
else
coef = 0.18;
else
if(this->Orientation == VTK_ORIENT_VERTICAL)
if (this->Orientation == VTK_ORIENT_VERTICAL )
coef = 0.6;
else
coef=0.25;
if ( this->Orientation == VTK_ORIENT_VERTICAL )
{
{
targetWidth = (int)(coef*size[0]);
targetHeight = (int)(0.86*size[1]/this->NumberOfLabels);
}
}
else
{
{
targetWidth = (int)(size[0]*0.8/this->NumberOfLabels);
targetHeight = (int)(coef*size[1]);
}
}
// rnv end
vtkTextMapper::SetMultipleConstrainedFontSize(viewport,
targetWidth,
targetHeight,
this->TextMappers,
this->NumberOfLabels,
labelSize);
}
vtkTextMapper::SetMultipleConstrainedFontSize( viewport,
targetWidth,
targetHeight,
this->TextMappers,
this->NumberOfLabels,
labelSize );
}
}
//----------------------------------------------------------------------------
void SMESH_ScalarBarActor::SizeTitle(int *titleSize,
int *size,
void SMESH_ScalarBarActor::SizeTitle(int *titleSize,
int *size,
vtkViewport *viewport)
{
titleSize[0] = titleSize[1] = 0;
if (this->Title == NULL || !strlen(this->Title))
if ( this->Title == NULL || !strlen(this->Title) )
{
return;
}
@ -899,36 +908,43 @@ void SMESH_ScalarBarActor::SizeTitle(int *titleSize,
/*--------------------------------------------------------------------------*/
void SMESH_ScalarBarActor::SetDistributionVisibility(int flag) {
myDistributionActor->SetVisibility(flag);
void SMESH_ScalarBarActor::SetDistributionVisibility( int flag )
{
myDistributionActor->SetVisibility( flag );
Modified();
}
/*--------------------------------------------------------------------------*/
int SMESH_ScalarBarActor::GetDistributionVisibility() {
int SMESH_ScalarBarActor::GetDistributionVisibility()
{
return myDistributionActor->GetVisibility();
}
void SMESH_ScalarBarActor::SetDistribution(std::vector<int> theNbValues) {
void SMESH_ScalarBarActor::SetDistribution( const std::vector<int>& theNbValues )
{
myNbValues = theNbValues;
}
void SMESH_ScalarBarActor::SetDistributionColor (double rgb[3]) {
void SMESH_ScalarBarActor::SetDistributionColor( double rgb[3] )
{
myDistributionActor->GetProperty()->SetColor(rgb);
Modified();
}
void SMESH_ScalarBarActor::GetDistributionColor (double rgb[3]) {
void SMESH_ScalarBarActor::GetDistributionColor( double rgb[3] )
{
myDistributionActor->GetProperty()->GetColor(rgb);
}
void SMESH_ScalarBarActor::SetTitleOnlyVisibility( bool theTitleOnlyVisibility) {
void SMESH_ScalarBarActor::SetTitleOnlyVisibility( bool theTitleOnlyVisibility )
{
myTitleOnlyVisibility = theTitleOnlyVisibility;
}
bool SMESH_ScalarBarActor::GetTitleOnlyVisibility() {
bool SMESH_ScalarBarActor::GetTitleOnlyVisibility()
{
return myTitleOnlyVisibility;
}

2
src/OBJECT/SMESH_ScalarBarActor.h
View File

@ -174,7 +174,7 @@ class SMESHOBJECT_EXPORT SMESH_ScalarBarActor: public vtkActor2D {
virtual int GetDistributionVisibility();
// Description:
// Set distribution
virtual void SetDistribution(std::vector<int> theNbValues);
virtual void SetDistribution(const std::vector<int>& theNbValues);
// Description:
// Set distribution coloring type (SMESH_MONOCOLOR_TYPE or SMESH_MULTICOLOR_TYPE)

2
src/SMESHGUI/SMESHGUI_DisplayEntitiesDlg.cxx
View File

@ -97,7 +97,7 @@ SMESHGUI_DisplayEntitiesDlg::SMESHGUI_DisplayEntitiesDlg( QWidget* parent )
hl->addWidget( nb0DElemsLab, 0, 1 );
my0DElemsTB->setEnabled( nbElements );
nb0DElemsLab->setEnabled( nbElements );
myNbTypes += ( nbElements > 0 );
myNbTypes = ( nbElements > 0 );
// Edges
nbElements = myActor ? myActor->GetObject()->GetNbEntities( SMDSAbs_Edge ) : aMesh->NbEdges();

320
src/StdMeshers/StdMeshers_ProjectionUtils.cxx
View File

@ -28,6 +28,7 @@
#include "StdMeshers_ProjectionUtils.hxx"
#include "SMDS_EdgePosition.hxx"
#include "SMDS_FacePosition.hxx"
#include "SMESHDS_Mesh.hxx"
#include "SMESH_Algo.hxx"
#include "SMESH_Block.hxx"
@ -46,6 +47,7 @@
#include "utilities.h"
#include <BRepAdaptor_Surface.hxx>
#include <BRepMesh_Delaun.hxx>
#include <BRepTools.hxx>
#include <BRepTools_WireExplorer.hxx>
#include <BRep_Builder.hxx>
@ -2787,4 +2789,320 @@ namespace StdMeshers_ProjectionUtils
}
return true;
}
}
//================================================================================
/*!
* \brief Add in-FACE nodes surrounding a given node to a queue
*/
//================================================================================
typedef list< pair< const SMDS_MeshNode*, const BRepMesh_Triangle* > > TNodeTriaList;
void addCloseNodes( const SMDS_MeshNode* srcNode,
const BRepMesh_Triangle* bmTria,
const int srcFaceID,
TNodeTriaList & noTriQueue )
{
// find in-FACE nodes
SMDS_ElemIteratorPtr elems = srcNode->GetInverseElementIterator(SMDSAbs_Face);
while ( elems->more() )
{
const SMDS_MeshElement* elem = elems->next();
if ( elem->getshapeId() == srcFaceID )
{
for ( int i = 0, nb = elem->NbNodes(); i < nb; ++i )
{
const SMDS_MeshNode* n = elem->GetNode( i );
if ( !n->isMarked() )
noTriQueue.push_back( make_pair( n, bmTria ));
}
}
}
}
//================================================================================
/*!
* \brief Find a delauney triangle containing a given 2D point and return
* barycentric coordinates within the found triangle
*/
//================================================================================
const BRepMesh_Triangle* findTriangle( const gp_XY& uv,
const BRepMesh_Triangle* bmTria,
Handle(BRepMesh_DataStructureOfDelaun)& triaDS,
double bc[3] )
{
int nodeIDs[3];
gp_XY nodeUVs[3];
int linkIDs[3];
Standard_Boolean ori[3];
while ( bmTria )
{
// check bmTria
triaDS->ElementNodes( *bmTria, nodeIDs );
nodeUVs[0] = triaDS->GetNode( nodeIDs[0] ).Coord();
nodeUVs[1] = triaDS->GetNode( nodeIDs[1] ).Coord();
nodeUVs[2] = triaDS->GetNode( nodeIDs[2] ).Coord();
SMESH_MeshAlgos::GetBarycentricCoords( uv,
nodeUVs[0], nodeUVs[1], nodeUVs[2],
bc[0], bc[1] );
if ( bc[0] >= 0 && bc[1] >= 0 && bc[0] + bc[1] <= 1 )
{
bc[2] = 1 - bc[0] - bc[1];
return bmTria;
}
// look for a neighbor triangle, which is adjacent to a link intersected
// by a segment( triangle center -> uv )
gp_XY gc = ( nodeUVs[0] + nodeUVs[1] + nodeUVs[2] ) / 3.;
gp_XY seg = uv - gc;
bmTria->Edges( linkIDs, ori );
int triaID = triaDS->IndexOf( *bmTria );
bmTria = 0;
for ( int i = 0; i < 3; ++i )
{
const BRepMesh_PairOfIndex & triIDs = triaDS->ElementsConnectedTo( linkIDs[i] );
if ( triIDs.Extent() < 2 )
continue; // no neighbor triangle
// check if a link intersects gc2uv
const BRepMesh_Edge & link = triaDS->GetLink( linkIDs[i] );
const BRepMesh_Vertex & n1 = triaDS->GetNode( link.FirstNode() );
const BRepMesh_Vertex & n2 = triaDS->GetNode( link.LastNode() );
gp_XY uv1 = n1.Coord();
gp_XY lin = n2.Coord() - uv1; // link direction
double crossSegLin = seg ^ lin;
if ( Abs( crossSegLin ) < std::numeric_limits<double>::min() )
continue; // parallel
double uSeg = ( uv1 - gc ) ^ lin / crossSegLin;
if ( 0. <= uSeg && uSeg <= 1. )
{
bmTria = & triaDS->GetElement( triIDs.Index( 1 + ( triIDs.Index(1) == triaID )));
break;
}
}
}
return bmTria;
}
//================================================================================
/*!
* \brief triangulate the srcFace in 2D
* \param [in] srcWires - boundary of the src FACE
*/
//================================================================================
Morph::Morph(const TSideVector& srcWires)
{
_srcSubMesh = srcWires[0]->GetMesh()->GetSubMesh( srcWires[0]->Face() );
// compute _scale
{
BRepAdaptor_Surface surf( srcWires[0]->Face() );
const int nbDiv = 100;
const double uRange = surf.LastUParameter() - surf.FirstUParameter();
const double vRange = surf.LastVParameter() - surf.FirstVParameter();
const double dU = uRange / nbDiv;
const double dV = vRange / nbDiv;
double u = surf.FirstUParameter(), v = surf.FirstVParameter();
gp_Pnt p0U = surf.Value( u, v ), p0V = p0U;
double lenU = 0, lenV = 0;
for ( ; u < surf.LastUParameter(); u += dU, v += dV )
{
gp_Pnt p1U = surf.Value( u, surf.FirstVParameter() );
lenU += p1U.Distance( p0U );
p0U = p1U;
gp_Pnt p1V = surf.Value( surf.FirstUParameter(), v );
lenV += p1V.Distance( p0V );
p0V = p1V;
}
_scale.SetCoord( lenU / uRange, lenV / vRange );
}
// count boundary points
int iP = 1, nbP = 0;
for ( size_t iW = 0; iW < srcWires.size(); ++iW )
nbP += srcWires[iW]->NbPoints() - 1; // 1st and last points coincide
_bndSrcNodes.resize( nbP + 1 ); _bndSrcNodes[0] = 0;
// fill boundary points
BRepMesh::Array1OfVertexOfDelaun srcVert( 1, 1 + nbP );
BRepMesh_Vertex v( 0, 0, BRepMesh_Frontier );
for ( size_t iW = 0; iW < srcWires.size(); ++iW )
{
const UVPtStructVec& srcPnt = srcWires[iW]->GetUVPtStruct();
for ( int i = 0, nb = srcPnt.size() - 1; i < nb; ++i, ++iP )
{
_bndSrcNodes[ iP ] = srcPnt[i].node;
srcPnt[i].node->setIsMarked( true );
v.ChangeCoord() = srcPnt[i].UV().Multiplied( _scale );
srcVert( iP ) = v;
}
}
// triangulate the srcFace in 2D
BRepMesh_Delaun delauney( srcVert );
_triaDS = delauney.Result();
}
//================================================================================
/*!
* \brief Move non-marked target nodes
* \param [in,out] tgtHelper - helper
* \param [in] tgtWires - boundary nodes of the target FACE; must be in the
* same order as the nodes in srcWires given in the constructor
* \param [in] src2tgtNodes - map of src -> tgt nodes
* \param [in] moveAll - to move all nodes; if \c false, move only non-marked nodes
* \return bool - Ok or not
*/
//================================================================================
bool Morph::Perform(SMESH_MesherHelper& tgtHelper,
const TSideVector& tgtWires,
Handle(ShapeAnalysis_Surface) tgtSurface,
const TNodeNodeMap& src2tgtNodes,
const bool moveAll)
{
// get tgt boundary points corresponding to _bndSrcNodes
size_t nbP = 0;
for ( size_t iW = 0; iW < tgtWires.size(); ++iW )
nbP += tgtWires[iW]->NbPoints() - 1; // 1st and last points coincide
if ( nbP != _bndSrcNodes.size() - 1 )
return false;
BRepMesh::Array1OfVertexOfDelaun tgtVert( 1, 1 + nbP );
BRepMesh_Vertex v( 0, 0, BRepMesh_Frontier );
for ( size_t iW = 0, iP = 1; iW < tgtWires.size(); ++iW )
{
const UVPtStructVec& tgtPnt = tgtWires[iW]->GetUVPtStruct();
for ( int i = 0, nb = tgtPnt.size() - 1; i < nb; ++i, ++iP )
{
v.ChangeCoord() = tgtPnt[i].UV().Multiplied( _scale );
tgtVert( iP ) = v;
}
}
const TopoDS_Face& srcFace = TopoDS::Face( _srcSubMesh->GetSubShape() );
const int srcFaceID = _srcSubMesh->GetId();
SMESHDS_Mesh* tgtMesh = tgtHelper.GetMeshDS();
const SMDS_MeshNode *srcNode, *tgtNode;
const BRepMesh_Triangle *bmTria;
// initialize a queue of nodes with starting triangles
TNodeTriaList noTriQueue;
size_t iBndSrcN = 1;
for ( ; iBndSrcN < _bndSrcNodes.size() && noTriQueue.empty(); ++iBndSrcN )
{
// get a triangle
const BRepMesh::ListOfInteger & linkIds = _triaDS->LinksConnectedTo( iBndSrcN );
const BRepMesh_PairOfIndex & triaIds = _triaDS->ElementsConnectedTo( linkIds.First() );
const BRepMesh_Triangle& tria = _triaDS->GetElement( triaIds.Index(1) );
addCloseNodes( _bndSrcNodes[ iBndSrcN ], &tria, srcFaceID, noTriQueue );
}
// un-mark internal src nodes; later we will mark moved nodes
int nbSrcNodes = 0;
SMDS_NodeIteratorPtr nIt = _srcSubMesh->GetSubMeshDS()->GetNodes();
if ( !nIt || !nIt->more() ) return true;
if ( moveAll )
{
nbSrcNodes = _srcSubMesh->GetSubMeshDS()->NbNodes();
while ( nIt->more() )
nIt->next()->setIsMarked( false );
}
else
{
while ( nIt->more() )
nbSrcNodes += int( !nIt->next()->isMarked() );
}
// Move tgt nodes
double bc[3]; // barycentric coordinates
int nodeIDs[3];
bool checkUV = true;
const SMDS_FacePosition* pos;
while ( nbSrcNodes > 0 )
{
while ( !noTriQueue.empty() )
{
srcNode = noTriQueue.front().first;
bmTria = noTriQueue.front().second;
noTriQueue.pop_front();
if ( srcNode->isMarked() )
continue;
--nbSrcNodes;
srcNode->setIsMarked( true );
// find a delauney triangle containing the src node
gp_XY uv = tgtHelper.GetNodeUV( srcFace, srcNode, NULL, &checkUV );
uv *= _scale;
bmTria = findTriangle( uv, bmTria, _triaDS, bc );
if ( !bmTria )
continue;
// compute new coordinates for a corresponding tgt node
gp_XY uvNew( 0., 0. ), nodeUV;
_triaDS->ElementNodes( *bmTria, nodeIDs );
for ( int i = 0; i < 3; ++i )
uvNew += bc[i] * tgtVert( nodeIDs[i]).Coord();
uvNew.SetCoord( uvNew.X() / _scale.X(), uvNew.Y() / _scale.Y() );
gp_Pnt xyz = tgtSurface->Value( uvNew );
// find and move tgt node
TNodeNodeMap::const_iterator n2n = src2tgtNodes.find( srcNode );
if ( n2n == src2tgtNodes.end() ) continue;
tgtNode = n2n->second;
tgtMesh->MoveNode( tgtNode, xyz.X(), xyz.Y(), xyz.Z() );
if (( pos = dynamic_cast< const SMDS_FacePosition* >( tgtNode->GetPosition() )))
const_cast<SMDS_FacePosition*>( pos )->SetParameters( uvNew.X(), uvNew.Y() );
addCloseNodes( srcNode, bmTria, srcFaceID, noTriQueue );
}
if ( nbSrcNodes > 0 )
{
// assure that all src nodes are visited
for ( ; iBndSrcN < _bndSrcNodes.size() && noTriQueue.empty(); ++iBndSrcN )
{
const BRepMesh::ListOfInteger & linkIds = _triaDS->LinksConnectedTo( iBndSrcN );
const BRepMesh_PairOfIndex & triaIds = _triaDS->ElementsConnectedTo( linkIds.First() );
const BRepMesh_Triangle& tria = _triaDS->GetElement( triaIds.Index(1) );
addCloseNodes( _bndSrcNodes[ iBndSrcN ], &tria, srcFaceID, noTriQueue );
}
if ( noTriQueue.empty() )
{
SMDS_NodeIteratorPtr nIt = _srcSubMesh->GetSubMeshDS()->GetNodes();
while ( nIt->more() )
{
srcNode = nIt->next();
if ( !srcNode->isMarked() )
noTriQueue.push_back( make_pair( srcNode, bmTria ));
}
}
}
}
return true;
} // Morph::Perform
gp_XY Morph::GetBndUV(const int iNode) const
{
return _triaDS->GetNode( iNode ).Coord();
}
} // namespace StdMeshers_ProjectionUtils

32
src/StdMeshers/StdMeshers_ProjectionUtils.hxx
View File

@ -30,11 +30,14 @@
#include "SMESH_StdMeshers.hxx"
#include "StdMeshers_FaceSide.hxx"
#include "SMDS_MeshElement.hxx"
#include <BRepMesh_DataStructureOfDelaun.hxx>
#include <ShapeAnalysis_Surface.hxx>
#include <TopTools_DataMapOfShapeShape.hxx>
#include <TopTools_IndexedMapOfShape.hxx>
#include <TopTools_IndexedDataMapOfShapeListOfShape.hxx>
#include <TopTools_IndexedMapOfShape.hxx>
#include <TopoDS_Edge.hxx>
#include <TopoDS_Face.hxx>
#include <TopoDS_Vertex.hxx>
@ -136,6 +139,33 @@ namespace StdMeshers_ProjectionUtils
bool Invert();
};
/*!
* \brief Morph mesh on the target FACE to lie within FACE boundary w/o distortion
*/
class Morph
{
std::vector< const SMDS_MeshNode* > _bndSrcNodes;
Handle(BRepMesh_DataStructureOfDelaun) _triaDS;
SMESH_subMesh* _srcSubMesh;
bool _moveAll;
gp_XY _scale;
public:
Morph(const TSideVector& srcWires);
bool Perform(SMESH_MesherHelper& tgtHelper,
const TSideVector& tgtWires,
Handle(ShapeAnalysis_Surface) tgtSurface,
const TNodeNodeMap& src2tgtNodes,
const bool moveAll);
// return source boundary nodes. 0-th node is zero
const std::vector< const SMDS_MeshNode* >& GetBndNodes() const { return _bndSrcNodes; }
// return UV of the i-th source boundary node
gp_XY GetBndUV(const int iNode) const;
};
/*!
* \brief Looks for association of all sub-shapes of two shapes
* \param theShape1 - shape 1

238
src/StdMeshers/StdMeshers_Projection_2D.cxx
View File

@ -1179,240 +1179,6 @@ namespace {
return true;
}
typedef list< pair< const SMDS_MeshNode*, const BRepMesh_Triangle* > > TNodeTriaList;
//================================================================================
/*!
* \brief Add in-FACE nodes surrounding a given node to a queue
*/
//================================================================================
void addCloseNodes( const SMDS_MeshNode* srcNode,
const BRepMesh_Triangle* bmTria,
const int srcFaceID,
TNodeTriaList & noTriQueue )
{
// find in-FACE nodes
SMDS_ElemIteratorPtr elems = srcNode->GetInverseElementIterator(SMDSAbs_Face);
while ( elems->more() )
{
const SMDS_MeshElement* elem = elems->next();
if ( elem->getshapeId() == srcFaceID )
{
for ( int i = 0, nb = elem->NbNodes(); i < nb; ++i )
{
const SMDS_MeshNode* n = elem->GetNode( i );
if ( !n->isMarked() )
noTriQueue.push_back( make_pair( n, bmTria ));
}
}
}
}
//================================================================================
/*!
* \brief Find a delauney triangle containing a given 2D point and return
* barycentric coordinates within the found triangle
*/
//================================================================================
const BRepMesh_Triangle* findTriangle( const gp_XY& uv,
const BRepMesh_Triangle* bmTria,
Handle(BRepMesh_DataStructureOfDelaun)& triaDS,
double bc[3] )
{
int nodeIDs[3];
gp_XY nodeUVs[3];
int linkIDs[3];
Standard_Boolean ori[3];
while ( bmTria )
{
// check bmTria
triaDS->ElementNodes( *bmTria, nodeIDs );
nodeUVs[0] = triaDS->GetNode( nodeIDs[0] ).Coord();
nodeUVs[1] = triaDS->GetNode( nodeIDs[1] ).Coord();
nodeUVs[2] = triaDS->GetNode( nodeIDs[2] ).Coord();
SMESH_MeshAlgos::GetBarycentricCoords( uv,
nodeUVs[0], nodeUVs[1], nodeUVs[2],
bc[0], bc[1] );
if ( bc[0] >= 0 && bc[1] >= 0 && bc[0] + bc[1] <= 1 )
{
bc[2] = 1 - bc[0] - bc[1];
return bmTria;
}
// look for a neighbor triangle, which is adjacent to a link intersected
// by a segment( triangle center -> uv )
gp_XY gc = ( nodeUVs[0] + nodeUVs[1] + nodeUVs[2] ) / 3.;
gp_XY seg = uv - gc;
bmTria->Edges( linkIDs, ori );
int triaID = triaDS->IndexOf( *bmTria );
bmTria = 0;
for ( int i = 0; i < 3; ++i )
{
const BRepMesh_PairOfIndex & triIDs = triaDS->ElementsConnectedTo( linkIDs[i] );
if ( triIDs.Extent() < 2 )
continue; // no neighbor triangle
// check if a link intersects gc2uv
const BRepMesh_Edge & link = triaDS->GetLink( linkIDs[i] );
const BRepMesh_Vertex & n1 = triaDS->GetNode( link.FirstNode() );
const BRepMesh_Vertex & n2 = triaDS->GetNode( link.LastNode() );
gp_XY uv1 = n1.Coord();
gp_XY lin = n2.Coord() - uv1; // link direction
double crossSegLin = seg ^ lin;
if ( Abs( crossSegLin ) < std::numeric_limits<double>::min() )
continue; // parallel
double uSeg = ( uv1 - gc ) ^ lin / crossSegLin;
if ( 0. <= uSeg && uSeg <= 1. )
{
bmTria = & triaDS->GetElement( triIDs.Index( 1 + ( triIDs.Index(1) == triaID )));
break;
}
}
}
return bmTria;
}
//================================================================================
/*!
* \brief Morph mesh on the target face to lie within FACE boundary w/o distortion
*
* algo:
* - make a CDT on the src FACE
* - find a triangle containing a src node and get its barycentric coordinates
* - move the node to a point with the same barycentric coordinates in a corresponding
* tgt triangle
*/
//================================================================================
bool morph( SMESH_MesherHelper& tgtHelper,
const TopoDS_Face& tgtFace,
const TopoDS_Face& srcFace,
const TSideVector& tgtWires,
const TSideVector& srcWires,
const TAssocTool::TNodeNodeMap& src2tgtNodes )
{
if ( srcWires.size() != tgtWires.size() ) return false;
if ( srcWires.size() == 1 ) return false; // tmp
// count boundary points
int iP = 1, nbP = 0;
for ( size_t iW = 0; iW < srcWires.size(); ++iW )
nbP += srcWires[iW]->NbPoints() - 1; // 1st and last points coincide
// fill boundary points
BRepMesh::Array1OfVertexOfDelaun srcVert( 1, 1 + nbP ), tgtVert( 1, 1 + nbP );
vector< const SMDS_MeshNode* > bndSrcNodes( nbP + 1 ); bndSrcNodes[0] = 0;
BRepMesh_Vertex v( 0, 0, BRepMesh_Frontier );
for ( size_t iW = 0; iW < srcWires.size(); ++iW )
{
const UVPtStructVec& srcPnt = srcWires[iW]->GetUVPtStruct();
const UVPtStructVec& tgtPnt = tgtWires[iW]->GetUVPtStruct();
if ( srcPnt.size() != tgtPnt.size() ) return false;
for ( int i = 0, nb = srcPnt.size() - 1; i < nb; ++i, ++iP )
{
bndSrcNodes[ iP ] = srcPnt[i].node;
srcPnt[i].node->setIsMarked( true );
v.ChangeCoord() = srcPnt[i].UV();
srcVert( iP ) = v;
v.ChangeCoord() = tgtPnt[i].UV();
tgtVert( iP ) = v;
}
}
// triangulate the srcFace in 2D
BRepMesh_Delaun delauney( srcVert );
Handle(BRepMesh_DataStructureOfDelaun) triaDS = delauney.Result();
Handle(ShapeAnalysis_Surface) tgtSurface = tgtHelper.GetSurface( tgtFace );
SMESHDS_Mesh* srcMesh = srcWires[0]->GetMesh()->GetMeshDS();
SMESHDS_Mesh* tgtMesh = tgtHelper.GetMeshDS();
const SMDS_MeshNode *srcNode, *tgtNode;
const BRepMesh_Triangle *bmTria;
// un-mark internal src nodes; later we will mark moved nodes
SMDS_NodeIteratorPtr nIt = srcMesh->MeshElements( srcFace )->GetNodes();
if ( !nIt || !nIt->more() ) return true;
while ( nIt->more() )
( srcNode = nIt->next() )->setIsMarked( false );
// initialize a queue of nodes with starting triangles
const int srcFaceID = srcNode->getshapeId();
TNodeTriaList noTriQueue;
size_t iBndSrcN = 1;
for ( ; iBndSrcN < bndSrcNodes.size() && noTriQueue.empty(); ++iBndSrcN )
{
// get a triangle
const BRepMesh::ListOfInteger & linkIds = triaDS->LinksConnectedTo( iBndSrcN );
const BRepMesh_PairOfIndex & triaIds = triaDS->ElementsConnectedTo( linkIds.First() );
const BRepMesh_Triangle& tria = triaDS->GetElement( triaIds.Index(1) );
addCloseNodes( bndSrcNodes[ iBndSrcN ], &tria, srcFaceID, noTriQueue );
}
// Move tgt nodes
double bc[3]; // barycentric coordinates
int nodeIDs[3];
bool checkUV = true;
const SMDS_FacePosition* pos;
while ( !noTriQueue.empty() )
{
srcNode = noTriQueue.front().first;
bmTria = noTriQueue.front().second;
noTriQueue.pop_front();
if ( srcNode->isMarked() )
continue;
srcNode->setIsMarked( true );
// find a delauney triangle containing the src node
gp_XY uv = tgtHelper.GetNodeUV( srcFace, srcNode, NULL, &checkUV );
bmTria = findTriangle( uv, bmTria, triaDS, bc );
if ( !bmTria )
continue;
// compute new coordinates for a corresponding tgt node
gp_XY uvNew( 0., 0. ), nodeUV;
triaDS->ElementNodes( *bmTria, nodeIDs );
for ( int i = 0; i < 3; ++i )
uvNew += bc[i] * tgtVert( nodeIDs[i]).Coord();
gp_Pnt xyz = tgtSurface->Value( uvNew );
// find and move tgt node
TAssocTool::TNodeNodeMap::const_iterator n2n = src2tgtNodes.find( srcNode );
if ( n2n == src2tgtNodes.end() ) continue;
tgtNode = n2n->second;
tgtMesh->MoveNode( tgtNode, xyz.X(), xyz.Y(), xyz.Z() );
if (( pos = dynamic_cast< const SMDS_FacePosition* >( tgtNode->GetPosition() )))
const_cast<SMDS_FacePosition*>( pos )->SetParameters( uvNew.X(), uvNew.Y() );
addCloseNodes( srcNode, bmTria, srcFaceID, noTriQueue );
// assure that all src nodes are visited
for ( ; iBndSrcN < bndSrcNodes.size() && noTriQueue.empty(); ++iBndSrcN )
{
const BRepMesh::ListOfInteger & linkIds = triaDS->LinksConnectedTo( iBndSrcN );
const BRepMesh_PairOfIndex & triaIds = triaDS->ElementsConnectedTo( linkIds.First() );
const BRepMesh_Triangle& tria = triaDS->GetElement( triaIds.Index(1) );
addCloseNodes( bndSrcNodes[ iBndSrcN ], &tria, srcFaceID, noTriQueue );
}
}
return true;
}
//=======================================================================
/*
* Set initial association of VERTEXes for the case of projection
@ -1933,7 +1699,9 @@ bool StdMeshers_Projection_2D::Compute(SMESH_Mesh& theMesh, const TopoDS_Shape&
// ----------------------------------------------------------------
if ( helper.IsDistorted2D( tgtSubMesh, /*checkUV=*/false, &helper ))
{
morph( helper, tgtFace, srcFace, tgtWires, srcWires, _src2tgtNodes );
TAssocTool::Morph morph( srcWires );
morph.Perform( helper, tgtWires, helper.GetSurface( tgtFace ),
_src2tgtNodes, /*moveAll=*/true );
if ( !fixDistortedFaces( helper, tgtWires ))
return error("Invalid mesh generated");

650
src/StdMeshers/StdMeshers_ViscousLayers.cxx
View File

File diff suppressed because it is too large Load Diff