void PFO_CubeColorBlockGL::GetCoords(int            indx,
                                 SC_CoordArray& topCoords,
                                 SC_CoordArray& bottomCoords,
                                 const double&  reduceFactor)
{

    cubeData->GetBlockCoords(indx, topCoords, bottomCoords);

    if (reduceFactor < 0.999)
    {
        Line3D pointLine;
        pointLine.stPt = cubeData->GetCoord(indx);

        for (int k = 0; k < topCoords.Size(); k++)
        {
            pointLine.endPt = topCoords[k];
            topCoords[k] = pointLine.PointOnLine(reduceFactor);
            pointLine.endPt = bottomCoords[k];
            bottomCoords[k] = pointLine.PointOnLine(reduceFactor);
        }
    }
    MapCoords(topCoords);
    MapCoords(bottomCoords);
}
Beispiel #2
0
void PFO_GridContour:: CalcOutput(FOcalcType  calcType)
{
    DoStatusChk();
    if (StatusNotOK())
        return;

    SC_DoubleArray contourData;
    gridData->GetData(contourData);

    if (contourSpec.doLogContours)
        contourData.Log10();

    if (contourData.GetnDataOK() < 3)
    {
        SetObjErrMsg("less than 3 valid data");
        return;
    }

    SC_Triangulation& currTri = gridData->GetTriangulation();

    contourLines.Alloc(contourSpec.Size());
    SC_IntArray  orderedPoints;
    Line3D       cLine;
    Coord3D      nextPoint;

    for (int i = 0; i < contourSpec.Size(); i++)
    {
        double currVal = contourSpec[i].contourVal;
        if (contourSpec.doLogContours)
            currVal = log10(currVal);

        if (currTri.GetConnectedEdgeList(contourData, currVal, orderedPoints))
        {
            contourLines[i].Alloc(orderedPoints.Size());
            for (int j = 0; j < orderedPoints.Size(); j++)
            {
                int edgeIndex = orderedPoints[j];
                if (edgeIndex < 0)
                {
                    nextPoint = Coord3D();
                }
                else
                {
                    const SC_Triangulation::TriangleEdge& currEdge = currTri.GetEdge(edgeIndex);
                    currTri.GetNodeCoord(currEdge.stNode, cLine.stPt);
                    currTri.GetNodeCoord(currEdge.endNode, cLine.endPt);

                    // slight kluge: if Z is same, honor log stuff
                    if ((zvalueSource == zvs_Same) && contourSpec.doLogContours)
                    {
                        cLine.stPt.cZ = contourData[currEdge.stNode];
                        cLine.endPt.cZ = contourData[currEdge.endNode];
                        nextPoint = cLine.PointOnLine(currEdge.cPos);
                        nextPoint.cZ = InvLgt(nextPoint.cZ);
                    }
                    else
                    {
                        cLine.stPt.cZ = GetZVal(currEdge.stNode, *gridData);
                        cLine.endPt.cZ = GetZVal(currEdge.endNode, *gridData);
                        nextPoint = cLine.PointOnLine(currEdge.cPos);
                    }

                    // just affects X & Y
                    gridData->UnTransformCoord(nextPoint);
                    MapCoords(nextPoint);
                }


                contourLines[i] += nextPoint;
            }
        }
    }
    contourLines.SetSize(contourSpec.Size());
}