void lucScalarFieldCrossSection_DrawCrossSection( void* drawingObject, lucDatabase* database, Bool backFacing)
{
lucScalarFieldCrossSection* self = (lucScalarFieldCrossSection*)drawingObject;
/* Sample the 2d cross-section */
lucCrossSection_SampleField(self, backFacing);
/* Calibrate Colour Map */
if (self->colourMap)
lucColourMap_CalibrateFromFieldVariable(self->colourMap, self->fieldVariable);
if (self->context->rank == 0)
{
int d;
int count = self->resolutionA * self->resolutionB;
lucDatabase_AddGridVertices(database, count, self->resolutionB, &self->vertices[0][0][0]);
lucDatabase_AddValues(database, count, lucGridType, lucColourValueData, self->colourMap, &self->values[0][0][0]);
/* Flip normal if back facing */
if (backFacing)
for (d=0; d<3; d++)
self->normal[d] = 0 - self->normal[d];
/* Add a single normal value */
lucDatabase_AddNormal(database, lucGridType, self->normal);
}
/* Free memory */
lucCrossSection_FreeSampleData(self);
/* Start new geometry section - when used with multiple sections */
lucDatabase_OutputGeometry(database, self->id);
}
void _lucIsosurface_Write( void* drawingObject, lucDatabase* database, Bool walls )
{
/* Export surface triangles */
lucIsosurface* self = (lucIsosurface*)drawingObject;
Index triangle_I;
int i;
for ( triangle_I = 0 ; triangle_I < self->triangleCount ; triangle_I++)
{
if (self->triangleList[triangle_I].wall != walls) continue;
for (i=0; i<3; i++)
{
/* Dump vertex pos, [value] */
float coordf[3] = {self->triangleList[triangle_I].pos[i][0],
self->triangleList[triangle_I].pos[i][1],
self->triangleList[triangle_I].pos[i][2]};
float value = self->triangleList[triangle_I].value[i];
lucDatabase_AddVertices(database, 1, lucTriangleType, coordf);
if (self->colourField && self->colourMap)
lucDatabase_AddValues(database, 1, lucTriangleType, lucColourValueData, self->colourMap, &value);
}
}
}
void _lucSwarmVectors_PlotParticle( void* drawingObject, lucDatabase* database, Particle_Index lParticle_I )
{
lucSwarmVectors* self = (lucSwarmVectors*)drawingObject;
SwarmVariable* lengthVariable = self->lengthVariable;
SwarmVariable* thicknessVariable = self->thicknessVariable;
float length;
XYZ direction = { 1, 0, 0 };
SwarmVariable_ValueAt( self->directionVariable, lParticle_I, direction );
length = lucSwarmViewer_GetScalar(lengthVariable, lParticle_I, self->length);
//float max = self->directionVariable ? FieldVariable_GetMaxGlobalFieldMagnitude( self->directionVariable ) : 0;
float vecf[3] = {direction[0]*length, direction[1]*length, direction[2]*length};
lucDatabase_AddVectors(database, 1, lucVectorType, 0, 0, vecf);
if (thicknessVariable)
{
float thickness = lucSwarmViewer_GetScalar(thicknessVariable, lParticle_I, self->thickness);
lucDatabase_AddValues(database, 1, self->geomType, lucXWidthData, NULL, &thickness);
}
}
void _lucIsosurfaceCrossSection_Draw( void* drawingObject, lucDatabase* database, void* _context )
{
lucIsosurfaceCrossSection* self = (lucIsosurfaceCrossSection*)drawingObject;
lucIsosurface* isosurf = self->isosurface;
double minIsovalue = self->minIsovalue;
double maxIsovalue = self->maxIsovalue;
lucColourMap* colourMap = self->colourMap;
int i, j, k;
double isovalue;
Index triangle_I;
/* Custom max, min, use global min/max if equal (defaults to both zero) */
if (minIsovalue == maxIsovalue)
{
//minIsovalue = FieldVariable_GetMinGlobalFieldMagnitude(self->fieldVariable);
//maxIsovalue = FieldVariable_GetMaxGlobalFieldMagnitude(self->fieldVariable);
}
if (colourMap)
lucColourMap_SetMinMax(colourMap, minIsovalue, maxIsovalue);
/* Copy object id */
isosurf->id = self->id;
if (self->rank == 0)
{
/* Calculate a value we can use to offset each surface section slightly
* so they appear in the same position but don't actually overlap */
Coord min, max;
float shift = 0;
float range = 0;
int d;
Mesh_GetGlobalCoordRange(self->mesh, min, max );
for (d=0; d<3; d++)
range += (max[d] - min[d]) / 5000.0;
range /= 3.0;
/* Allocate Memory */
Vertex** points = Memory_Alloc_2DArray( Vertex , 8, 1, "array for marching squares");
/* Draw isovalues at each interval from min to max */
for ( isovalue = minIsovalue ; isovalue <= maxIsovalue ; isovalue += self->interval )
{
float nshift[3] = {shift * self->normal[0], shift * self->normal[1], shift * self->normal[2]};
shift += range;
isosurf->triangleCount = 0; /* Reset */
isosurf->colourMap = NULL;
if ( colourMap )
lucColourMap_GetColourFromValue(colourMap, isovalue, &isosurf->colour, self->opacity);
/* Run marching rectangles for this isovalue */
isosurf->isovalue = isovalue;
for ( i = 0 ; i < self->resolutionA-1 ; i++ )
{
for ( j = 0 ; j < self->resolutionB-1 ; j++ )
{
/* Copy vertex */
for (k = 0; k<3; k++)
{
points[LEFT_BOTTOM]->pos[k] = self->vertices[i][j][k] + nshift[k];
points[RIGHT_BOTTOM]->pos[k] = self->vertices[i+1][j][k] + nshift[k];
points[LEFT_TOP]->pos[k] = self->vertices[i][j+1][k] + nshift[k];
points[RIGHT_TOP]->pos[k] = self->vertices[i+1][j+1][k] + nshift[k];
}
/* Copy value */
points[LEFT_BOTTOM]->value = self->values[i][j][0];
points[RIGHT_BOTTOM]->value = self->values[i+1][j][0];
points[LEFT_TOP]->value = self->values[i][j+1][0];
points[RIGHT_TOP]->value = self->values[i+1][j+1][0];
/* Interpolate mid-points and create triangles */
lucIsosurface_WallElement( isosurf, points );
}
}
/* Draw the surface section */
isosurf->colourMap = self->colourMap;
_lucIsosurface_Draw(self->isosurface, database, _context );
/* Export colour values */
if (self->colourMap)
{
float iso = isovalue;
for ( triangle_I = 0 ; triangle_I < isosurf->triangleCount ; triangle_I++)
for (i=0; i<3; i++)
lucDatabase_AddValues(database, 1, lucTriangleType, lucColourValueData, self->colourMap, &iso);
}
}
Memory_Free( points );
}
/* Free memory */
lucCrossSection_FreeSampleData(self);
}
void lucContourCrossSection_PlotPoint(lucContourCrossSection* self, lucDatabase* database, char edge, double isovalue, int aIndex, int bIndex)
{
Coord vertex;
double aPos = (double)aIndex;
double bPos = (double)bIndex;
double leftBtm = self->values[aIndex][bIndex][0];
double rightBtm = self->values[aIndex+1][bIndex][0];
double leftTop = self->values[aIndex][bIndex+1][0];
double rightTop = self->values[aIndex+1][bIndex+1][0];
switch (edge)
{
case BOTTOM:
aPos += (isovalue - leftBtm)/(rightBtm - leftBtm);
break;
case TOP:
aPos += (isovalue - leftTop)/(rightTop - leftTop);
bPos += 1.0;
break;
case LEFT:
bPos += (isovalue - leftBtm)/(leftTop - leftBtm);
break;
case RIGHT:
aPos += 1.0;
bPos += (isovalue - rightBtm)/(rightTop - rightBtm);
break;
}
lucCrossSection_Interpolate2d(self, aPos / (double)(self->resolutionA-1), bPos / (double)(self->resolutionB-1), vertex);
/* Dump vertex pos */
float pos[3] = {vertex[0], vertex[1], vertex[2]};
float value = isovalue;
lucDatabase_AddVertices(database, 1, lucLineType, pos);
if (self->colourMap)
lucDatabase_AddValues(database, 1, lucLineType, lucColourValueData, self->colourMap, &value);
if (self->showValues && self->coordIndex % 4 == edge)
{
if (self->printedIndex < self->coordIndex && (0 == bIndex || 0 == aIndex || bIndex == (self->resolutionB-1) || aIndex == (self->resolutionA-1)))
{
char label[32];
double dimCoeff = 1.0; /* coefficient for dimensionalising field */
//TODO: Fix scaling/units
// /* very hacky to get the scaling component */
// Scaling* theScaling = NULL;
// if (self->fieldVariable->context) theScaling = self->fieldVariable->context->scaling;
// if (self->fieldVariable->o_units && theScaling)
// dimCoeff = Scaling_ParseDimCoeff( theScaling, self->fieldVariable->o_units );
//
/* Add the vertex for the label as a point */
lucDatabase_AddVertices(database, 1, lucPointType, pos);
/* Add to the label data */
sprintf(label, " %g", isovalue * dimCoeff);
//sprintf(label, " %g%s", isovalue * dimCoeff,
// self->printUnits && self->fieldVariable->o_units ? self->fieldVariable->o_units : "");
lucDatabase_AddLabel(database, lucPointType, label);
self->printedIndex = self->coordIndex;
}
}
}
void _lucEigenvectorsCrossSection_DrawCrossSection( void* drawingObject, lucDatabase* database, Dimension_Index dim )
{
lucEigenvectorsCrossSection* self = (lucEigenvectorsCrossSection*)drawingObject;
FieldVariable* tensorField = self->fieldVariable;
SymmetricTensor tensor;
Eigenvector eigenvectorList[3];
Dimension_Index dim_I;
Index aIndex, bIndex;
/* Sample the 2d cross-section */
lucCrossSection_SampleField(self, False);
for ( aIndex = 0 ; aIndex < self->resolutionA ; aIndex++ )
{
for ( bIndex = 0 ; bIndex < self->resolutionB ; bIndex++ )
{
if (self->values[aIndex][bIndex][0] != HUGE_VAL)
{
/* Get tensor data & position */
int t;
for (t=0; t<tensorField->fieldComponentCount; t++)
tensor[t] = self->values[aIndex][bIndex][t];
SymmetricTensor_CalcAllEigenvectors( tensor, dim, eigenvectorList );
float pos[3] = {self->vertices[aIndex][bIndex][0], self->vertices[aIndex][bIndex][1], self->vertices[aIndex][bIndex][2]};
if (self->plotEigenVector)
{
for ( dim_I = 0 ; dim_I < dim ; dim_I++ )
{
float vec[3] = {eigenvectorList[ dim_I ].vector[0], eigenvectorList[ dim_I ].vector[1], eigenvectorList[ dim_I ].vector[2]};
lucDatabase_AddVertices(database, 1, lucVectorType, pos);
lucDatabase_AddRGBA(database, lucVectorType, self->opacity, &self->colours[ dim_I ]);
if (self->useEigenValue)
{
vec[0] *= eigenvectorList[ dim_I ].eigenvalue;
vec[1] *= eigenvectorList[ dim_I ].eigenvalue;
if (dim > 2)
vec[2] *= eigenvectorList[ dim_I ].eigenvalue;
else
vec[2] = 0;
}
lucDatabase_AddVectors(database, 1, lucVectorType, 0, 1, vec);
}
}
if (self->plotEigenValue)
{
float pointSize = 0;
for ( dim_I = 0 ; dim_I < dim ; dim_I++ )
{
lucDatabase_AddVertices(database, 1, lucShapeType, pos);
/* The EigenValue can be negative.... Got to attribute a potential */
/* colour for negative values, one for each dim as well */
if ( eigenvectorList[ dim_I ].eigenvalue >= 0)
{
pointSize = eigenvectorList[ dim_I ].eigenvalue;
lucDatabase_AddRGBA(database, lucShapeType, self->opacity, &self->colours[ dim_I ]);
}
else
{
pointSize = -eigenvectorList[ dim_I ].eigenvalue;
lucDatabase_AddRGBA(database, lucShapeType, self->opacity, &self->colourForNegative[ dim_I ]);
}
lucDatabase_AddValues(database, 1, lucShapeType, lucXWidthData, NULL, &pointSize);
}
}
}
}
}
lucCrossSection_FreeSampleData(self);
}
