# PipeProfileCAD.sml
#
# This script is meant to be run as a Toolscript
#
# Current Assumptions:
# In the group there are two layers:
# Layer 1: DEM - not needed
# Layer 2: Overlaying vector lines (must be last layer)
#
# Purpose:
# The script creates a window displaying a plotted profile of the
# selected lines nearest line, using the vector DB values for elevation.
# Only allows selection of contiguous connected lines, but can add to
# either end of selected line set. Active elements are highlighted in
# both the View and Line Profile window on mouseover in either window.
#
# Usage:
# Left click: toggle select/deselect line
# Right click: Accept current line and draw
# Save As button on Line Profile window saves the current graph to a CAD object.
#
# Requires TNTmips 7.0 dated 1 March 2005 or later.
## MicroImages, Inc.
## Revised 19 April 2005. Fixed inconsistency in placement of graph axis labels in
## Line Profile window and CAD.
# GUI global definitions
class GUI_DLG dlgwin;
class GUI_CANVAS canvas;
class GC gc; # global graphics context for drawing canvas in dialog
class GRDEVICE_CAD deviceCAD;
class GUI_CTRL_TOGGLEBUTTON gridToggle;
class GUI_CTRL_EDIT_NUMBER gridIntervalX;
class GUI_CTRL_EDIT_NUMBER gridIntervalY;
class GUI_CTRL_TOGGLEBUTTON demToggle;
class GUI_CTRL_EDIT_NUMBER graphMinSetting;
class GUI_CTRL_EDIT_NUMBER graphMaxSetting;
class GUI_CTRL_TOGGLEBUTTON fillToggle;
#class GUI_CTRL_EDIT_NUMBER elemDisplay;
#class GUI_CTRL_EDIT_NUMBER lineDisplay;
#class GUI_CTRL_EDIT_NUMBER vertexDisplay;
class GUI_CTRL_EDIT_NUMBER mouseXDisplay;
class GUI_CTRL_EDIT_NUMBER mouseYDisplay;
class GUI_CTRL_EDIT_NUMBER slopeDisplay;
class GUI_CTRL_EDIT_NUMBER diameterDisplay;
class GUI_CTRL_EDIT_STRING materialDisplay;
# Group/layer/object global definitions
class GRE_GROUP activegroup;
class TRANSPARM mapTrans;
class GRE_LAYER_VECTOR vectorLayer;
class GRE_LAYER_RASTER rasterLayer;
class VECTOR lineVector;
class GEOREF vecGeoref;
class RASTER dem;
string vectorName$;
class DBTABLEINFO nodeTable;
class DBTABLEINFO lineTable;
numeric dbIsInit=0;
class CAD CADgraph;
# Graphical display global definitions
class POLYLINE pipeBottom, pipeTop, pipeFace, surface;
class POLYLINE surface, manholeDepth, demSurface, smoothedSurface;
class STRINGLIST manholeNames;
class POLYLINE pipeBottomSave, pipeTopSave, pipeFaceSave; # used for highlighting
class STRINGLIST colors;
numeric drawable=0, demSet=0;
numeric graphMinZ, graphMaxZ, dataMinZ, dataMaxZ;
numeric setDefaultWhenClose = false;
numeric leftGraphOffset, bottomGraphOffset=20, rightGraphOffset=15, topGraphOffset=50; #5,15
numeric currentlyActive = -1;
numeric needsRedraw = 0;
# Utility global definitions
class POLYLINE demLine;
class STRINGLIST elemList;
class STRINGLIST orderedElemList;
class STRINGLIST reversedList;
array numeric endNodes[2];
numeric MAX_NUMBER = 9999999;
# <debug>
func writePolyline(class FILE f, class POLYLINE polyline)
{
local class POINT2D p2d;
local numeric i;
for (i=0; i<polyline.GetNumPoints(); i++)
{
p2d = polyline.GetVertex(i);
fwritestring(f, sprintf("(%.3f, %.3f)\n", p2d.x, p2d.y));
}
fwritestring(f, "\n");
}
# </debug>
func assignColors()
{
colors.AddToEnd("red");
colors.AddToEnd("orange");
colors.AddToEnd("yellow");
colors.AddToEnd("green");
colors.AddToEnd("blue");
colors.AddToEnd("purple");
colors.AddToEnd("violet");
}
func class COLOR getColor(numeric index)
{
local class COLOR c;
c.Name = colors.GetString(index%colors.GetNumItems()-1);
return c;
}
# Determine if the dem will be used or not
func doUseDEM()
{
return demToggle.GetValue();
}
# Get the line table by name - return 1 if successful, 0 if table is null
func initLineTable(string tablename)
{
local class DATABASE lineDB = OpenVectorLineDatabase(lineVector);
if (lineDB==0) return 0;
lineTable = DatabaseGetTableInfo(lineDB, tablename);
if (lineTable==0) return 0;
return 1;
}
# Get the node table by name - return 1 if successful, 0 if table is null
func initNodeTable(string tablename)
{
local class DATABASE nodeDB = OpenVectorNodeDatabase(lineVector);
if (nodeDB==0) return 0;
nodeTable = DatabaseGetTableInfo(nodeDB, tablename);
if (nodeTable==0) return 0;
return 1;
}
# Checks layer to see if it is valid.
func checkLayer()
{
if (doUseDEM())
{
# Raster is assumed to be first layer
rasterLayer = activegroup.FirstLayer;
if (rasterLayer.Type!="Raster")
{
demSet = 0;
PopupMessage("The first layer is not a raster, the DEM was not assigned properly and the script may not function properly.");
}
DispGetRasterFromLayer(dem, rasterLayer);
demSet = 1;
}
# Vector is assumed to be last layer
vectorLayer = activegroup.LastLayer;
DispGetVectorFromLayer(lineVector, vectorLayer);
vecGeoref = GetLastUsedGeorefObject(lineVector);
mapTrans.InputProjection = vectorLayer.Projection;
mapTrans.OutputProjection = rasterLayer.Projection;
# initialize the database tables
initLineTable("SEW_INFO");
initNodeTable("MH_GIS");
return 1;
}
# Callback for when the active layer changes.
proc cbLayer()
{
checkLayer();
}
# Callback for when the active group changes.
proc cbGroup()
{
activegroup = Layout.ActiveGroup;
WidgetAddCallback(activegroup.LayerSelectedCallback, cbLayer);
cbLayer();
}
# return the max of two numbers
func max(numeric n1, numeric n2)
{
if (n1 > n2) return n1;
return n2;
}
# Get the element from our list
func getElement(class STRINGLIST list, numeric index)
{
return StrToNum(list.GetString(index));
}
# Get the index of the element in our list, return index if found, -1 otherwise
func indexOf(class STRINGLIST list, numeric value)
{
local numeric i;
for (i=0; i<list.GetNumItems(); i++)
{
if (getElement(list, i)==value)
{
return i;
}
}
return -1;
}
# Determine if the two lines are consecutive (endpt1 == startpt2)
#func isConsecutive(class POLYLINE line, numeric vertexNum)
#{
# if (indexOf(endPoints, vertexNum)>-1)
# {
# local class POINT2D point1 = line.GetVertex(vertexNum);
# local class POINT2D point2 = line.GetVertex(vertexNum+1);
#
# if (point1!=point2)
# {
# return 0;
# }
# }
# return 1;
#}
# Compute the distance between two points
func computeDistance(class POINT2D p1, class POINT2D p2)
{
return sqrt((p2.x-p1.x)^2 + (p2.y-p1.y)^2);
}
# Determine if the given lin, col is within the raster extents
func isPointInRaster(numeric lin, numeric col)
{
if (lin<1 || col<1 || lin>NumLins(dem) || col>NumCols(dem)) return 0;
return 1;
}
# Get the value of the first record attached to the node "nodeNum" as a string
func string readNodeTableRecordStr(numeric nodeNum, string field)
{
local array numeric records[1];
TableReadAttachment(nodeTable, nodeNum, records, "node");
local string retVal = TableReadFieldStr(nodeTable, field, records[1]);
return retVal;
}
# Get the value of the first record attached to the line "lineNum" as a string
func string readLineTableRecordStr(numeric lineNum, string field)
{
local array numeric records[1];
TableReadAttachment(lineTable, lineNum, records, "line");
local string retVal = TableReadFieldStr(lineTable, field, records[1]);
return retVal;
}
# Get the value of the first record attached to the line "lineNum"
func readLineTableRecord(numeric lineNum, string field)
{
local array numeric records[1];
TableReadAttachment(lineTable, lineNum, records, "line");
local numeric retVal = TableReadFieldNum(lineTable, field, records[1]);
if (IsNull(retVal)) return 0;
return retVal;
}
# Get the value of the first record attached to the line "nodeNum"
func readNodeTableRecord(numeric nodeNum, string field)
{
local array numeric records[1];
TableReadAttachment(nodeTable, nodeNum, records, "node");
local numeric retVal = TableReadFieldNum(nodeTable, field, records[1]);
return retVal;
}
# Get the z value
func computeElevationFromDEM(class POINT2D p)
{
p = mapTrans.ConvertPoint2DFwd(p); # convert from vector map to raster map coords
local class POINT2D obj = MapToObject(GetLastUsedGeorefObject(dem), p.x, p.y, dem);
obj.x = obj.x + .5; # center of cell
obj.y = obj.y + .5; # center of cell
local numeric demValue;
if(isPointInRaster(obj.y, obj.x)) demValue = dem[obj.y, obj.x]; # y for line, x for column
else demValue = null;
return demValue;
}
# Find the closest line element using the polyline and the two nodes (vertices)
func findClosestLineElement(class POLYLINE origLine, numeric vertex1, numeric vertex2)
{
# get the line given the two end points - straight line assumed
local class POINT2D point1 = origLine.GetVertex(vertex1);
local class POINT2D point2 = origLine.GetVertex(vertex2);
local class POINT2D midPt = point1;
midPt = midPt + point2;
midPt.x = midPt.x / 2;
midPt.y = midPt.y / 2;
local numeric elemNum = FindClosestLine(lineVector, midPt.x, midPt.y);
return elemNum;
}
# Interpolate between two points adding extra vertices
func class POLYLINE constructSmoothSurface(class POLYLINE p, numeric linscale, numeric colscale, numeric samplingRate)
{
local class POLYLINE tmpLine, retLine;
local class POINT2D point1, point2, tmpPt;
local numeric numIntervals = 3;
local numeric i;
for (i=1; i<p.GetNumPoints(); i++)
{
point1 = p.GetVertex(i-1);
point2 = p.GetVertex(i);
local class POINT2D intervalPt = point2 - point1;
intervalPt.x = intervalPt.x / (numIntervals+1);
intervalPt.y = intervalPt.y / (numIntervals+1);
if (intervalPt.x != 0 && intervalPt.y != 0)
{
tmpPt = point1;
local numeric j;
for (j=0; j<=numIntervals+1; j++)
{
tmpLine.AppendVertex(tmpPt);
tmpPt = tmpPt + intervalPt;
}
}
}
local numeric distance=0;
local numeric elevation = computeElevationFromDEM(tmpLine.GetVertex(0));
tmpPt.x = distance;
tmpPt.y = elevation;
retLine.AppendVertex(tmpPt);
for (i=1; i<tmpLine.GetNumPoints(); i++)
{
distance += computeDistance(tmpLine.GetVertex(i-1), tmpLine.GetVertex(i));
elevation = computeElevationFromDEM(tmpLine.GetVertex(i));
tmpPt.x = distance;
tmpPt.y = elevation;
retLine.AppendVertex(tmpPt);
}
return retLine;
}
# Construct the DEM surface elevation line, x dimension is line distance y is elevation
func class POLYLINE constructDemSurface(class POLYLINE demLine, class POLYLINE interpolated)
{
local class POLYLINE retLine;
if (demLine.GetNumPoints()<1) return retLine;
local class POINT2D tmp;
local numeric i;
local numeric distance=0;
local numeric elevation = computeElevationFromDEM(demLine.GetVertex(0));
tmp.x = distance;
tmp.y = elevation;
retLine.AppendVertex(tmp);
# get the elevation values from the raster
for (i=1; i<demLine.GetNumPoints(); i++)
{
distance += computeDistance(demLine.GetVertex(i-1), demLine.GetVertex(i));
elevation = computeElevationFromDEM(demLine.GetVertex(i));
tmp.x = distance;
tmp.y = elevation;
retLine.AppendVertex(tmp);
}
return retLine;
}
# returns 1 if elemNum is reversed, 0 otherwise
func isLineReversed(numeric elemNum)
{
return StrToNum(reversedList.GetString(indexOf(elemList, elemNum)));
}
# Construct the surface elevation line, x dimension is line distance y is elevation
func class POLYLINE constructSurface(class POLYLINE origLine)
{
# DS == end node, US == start node
local string pipeField = "CAN_I_US";
local string surfField = "CAN_D_US";
local class POLYLINE newLine;
if (origLine.GetNumPoints()<1) return newLine;
local class POINT2D tmp;
local numeric i;
local numeric distance=0;
local numeric elemNum = findClosestLineElement(origLine, 0, 1);
# reversed line 0 - can happen if first line is toggled off (not used as we flip bits in that case)
if (isLineReversed(elemNum))
{
pipeField = "CAN_I_DS";
surfField = "CAN_D_DS";
}
# Get elevation from start node
local numeric elevation = readLineTableRecord(elemNum, pipeField) + readLineTableRecord(elemNum, surfField);
if (!IsNull(elevation))
{
tmp.x = distance;
tmp.y = elevation;
newLine.AppendVertex(tmp);
}
# get the elevation values from the database table
for (i=1; i<origLine.GetNumPoints(); i++)
{
local class POINT2D point1, point2;
point1 = origLine.GetVertex(i-1);
point2 = origLine.GetVertex(i);
local numeric dx = computeDistance(point1, point2);
distance += dx;
# DS == end node, US == start node
pipeField = "CAN_I_DS";
surfField = "CAN_D_DS";
local numeric k=0;
# dx ==0 means we found a start node (thus US)
if (dx==0)
{
k = 1;
pipeField = "CAN_I_US";
surfField = "CAN_D_US";
}
local numeric elemNum = findClosestLineElement(origLine, i-1+k, i+k);
# check if the line was reversed - need to change field used
if (isLineReversed(elemNum))
{
if (pipeField == "CAN_I_US") pipeField = "CAN_I_DS";
else if (pipeField == "CAN_I_DS") pipeField = "CAN_I_US";
if (surfField == "CAN_D_US") surfField = "CAN_D_DS";
else if (surfField == "CAN_D_DS") surfField = "CAN_D_US";
}
# Get elevation from end node
elevation = readLineTableRecord(elemNum, pipeField) + readLineTableRecord(elemNum, surfField);
if (!IsNull(elevation))
{
tmp.x = distance;
tmp.y = elevation;
newLine.AppendVertex(tmp);
}
}
return newLine;
}
# Construct the pipe face by creating a rectangle from four vertices of 'bottom' and 'top'
func class POLYLINE constructPipeFace(class POLYLINE bottom, class POLYLINE top)
{
local class POLYLINE ret;
if (bottom.GetNumPoints() != top.GetNumPoints())
{
numeric fillPipes = 0;
return ret;
}
local numeric i;
for (i=0; i<bottom.GetNumPoints(); i=i+2)
{
ret.AppendVertex(bottom.GetVertex(i)); # LL
ret.AppendVertex(bottom.GetVertex(i+1)); # LR
ret.AppendVertex(top.GetVertex(i+1)); # UR
ret.AppendVertex(top.GetVertex(i)); # UL
ret.AppendVertex(bottom.GetVertex(i)); # LL
}
return ret;
}
# Construct the pipe top - top.x = bottom.x && top.x = bottom.x + pipeHeight
func class POLYLINE constructPipeTop(class POLYLINE pipeBottom, class POLYLINE origLine)
{
local class POLYLINE newLine;
local class POINT2D tmp;
# get the pipe top by calculating as heigth offset from bottom pipe line
local numeric i;
for (i=0; i<origLine.GetNumPoints(); i++)
{
local numeric vertex1, vertex2;
if (i==0) vertex1 = i;
else vertex1 = i-1;
vertex2 = i;
local class POINT2D p1 = origLine.GetVertex(vertex1);
local class POINT2D p2 = origLine.GetVertex(vertex2);
if (p1==p2)
{
vertex1++;
vertex2++;
if (i==0) vertex1 = i;
}
local numeric elemNum = findClosestLineElement(origLine, vertex1, vertex2);
# Get elevation from end node
local numeric elevation = readLineTableRecord(elemNum, "CAN_DIAM")/1000 + pipeBottom.GetVertex(i).y;
if (!IsNull(elevation))
{
tmp.x = pipeBottom.GetVertex(i).x;
tmp.y = elevation;
newLine.AppendVertex(tmp);
}
}
return newLine;
}
# Construct the graph line, x dimension is line distance y is elevation
func class STRINGLIST constructManholeNames(class POLYLINE origLine)
{
local class STRINGLIST manholeNames;
local class POINT2D prevPoint;
# Draw all the manhole names at the manhole tops
local numeric i;
for (i=0; i<origLine.GetNumPoints(); i++)
{
# get the label
local class POINT2D point1 = origLine.GetVertex(i);
local string manholeLabel = "";
if (point1!=prevPoint)
{
local numeric elemNum = FindClosestNode(lineVector, point1.x, point1.y);
manholeLabel = readNodeTableRecordStr(elemNum, "MH_ID");
}
manholeNames.AddToEnd(manholeLabel);
prevPoint = point1;
}
return manholeNames;
}
# Construct the graph line, x dimension is line distance y is elevation
func class POLYLINE constructManholeDepth(class POLYLINE pipeBottom, class POLYLINE origLine)
{
local class POLYLINE newLine;
local class POINT2D tmp;
local numeric i;
for (i=0; i<origLine.GetNumPoints(); i++)
{
local class POINT2D point1 = origLine.GetVertex(i);
local numeric elemNum = FindClosestNode(lineVector, point1.x, point1.y);
# Get elevation from end node
local numeric elevation = readNodeTableRecord(elemNum, "MH_INVERT");
tmp.x = pipeBottom.GetVertex(i).x;
tmp.y = elevation;
newLine.AppendVertex(tmp);
}
return newLine;
}
# Construct the graph line, x dimension is line distance y is elevation
func class POLYLINE constructPipeBottom(class POLYLINE origLine)
{
local string field = "CAN_I_US";
local class POLYLINE newLine;
if (origLine.GetNumPoints()<1) return newLine;
local class POINT2D tmp;
local numeric i;
local numeric distance=0;
local numeric elemNum = findClosestLineElement(origLine, 0, 1);
# check if the line 0 was reversed -- can happen if first line was toggled off (not used as we flip bits in that case)
if (isLineReversed(elemNum))
{
field = "CAN_I_DS";
}
# Get elevation from start node
local numeric elevation = readLineTableRecord(elemNum, field);
if (!IsNull(elevation))
{
tmp.x = distance;
tmp.y = elevation;
newLine.AppendVertex(tmp);
}
for (i=1; i<origLine.GetNumPoints(); i++)
{
local class POINT2D point1, point2;
point1 = origLine.GetVertex(i-1);
point2 = origLine.GetVertex(i);
local numeric dx = computeDistance(point1, point2);
distance += dx;
field = "CAN_I_DS";
local numeric k=0;
if (dx==0)
{
k = 1;
field = "CAN_I_US";
}
local numeric elemNum = findClosestLineElement(origLine, i-1+k, i+k);
# check if the line was reversed
if (isLineReversed(elemNum))
{
if (field == "CAN_I_US") field = "CAN_I_DS";
else if (field == "CAN_I_DS") field = "CAN_I_US";
}
# Get elevation from end node
elevation = readLineTableRecord(elemNum, field);
if (!IsNull(elevation))
{
tmp.x = distance;
tmp.y = elevation;
newLine.AppendVertex(tmp);
}
}
return newLine;
}
# Determine if the value given is a null value
func isNull(numeric value)
{
# return (value<=0);
return (value < graphMinZ || value > graphMaxZ);
# return (value == NullValue(dem));
}
# Get the width from the appropriate drawing device
func getHeight()
{
return canvas.GetHeight();
}
# Get the width from the appropriate drawing device
func getWidth()
{
return canvas.GetWidth();
}
# Get the extents of the graph
# (x1, y1) == UL corner
# (x2, y2) == LR corner
func class RECT getGraphExtents()
{
local class RECT rect;
rect.x1 = leftGraphOffset;
rect.x2 = getWidth() - rightGraphOffset;
rect.y1 = topGraphOffset;
rect.y2 = getHeight() - bottomGraphOffset;
return rect;
}
# Set the affine transformation for distance/elevation -> Graph Coords
proc setTrans(class POLYLINE graphLine)
{
# copy the point
# local class POINT2D retpoint;
# retpoint = point;
#
# # get graph extents
# local numeric minx, maxx, miny, maxy;
# minx = leftGraphOffset;
# miny = topGraphOffset;
# maxx = getWidth() - rightGraphOffset;
# maxy = getHeight() - bottomGraphOffset;
#
# # Get the drawing scale
# local numeric xscale = 0, yscale = 0;
# xscale = (maxx - minx) / abs(graphLine.GetVertex(graphLine.GetNumPoints()-1).x - graphLine.GetVertex(0).x);
# if (graphMaxZ != graphMinZ) yscale = (maxy - miny) / (graphMaxZ - graphMinZ);
#
# # apply scales and offsets
# retpoint.x = point.x * xscale + leftGraphOffset;
# if (yscale!=0) retpoint.y = getHeight() - ((point.y-graphMinZ) * yscale + bottomGraphOffset);
# else retpoint.y = getHeight() - bottomGraphOffset;
# redefinition here clears the trans each time we draw (which is desirable)
class TRANSAFFINE trans;
trans.ApplyScale(1,1);
trans.ApplyOffset(0,0);
# get graph extents
local numeric minx, maxx, miny, maxy;
minx = leftGraphOffset;
miny = topGraphOffset;
maxx = getWidth() - rightGraphOffset;
maxy = getHeight() - bottomGraphOffset;
# Get the drawing scale
local numeric xscale = 0, yscale = 0;
xscale = (maxx - minx) / abs(graphLine.GetVertex(graphLine.GetNumPoints()-1).x - graphLine.GetVertex(0).x);
if (graphMaxZ != graphMinZ) yscale = (maxy - miny) / (graphMaxZ - graphMinZ);
# apply scales and offsets
trans.ApplyScale(xscale, -yscale);
trans.ApplyOffset(leftGraphOffset, getHeight() + graphMinZ*yscale - bottomGraphOffset);
}
# Create the GC here using the appropriate drawing device (gc is global)
proc createGC()
{
gc = canvas.CreateGC();
}
# draw the graph background fill
proc drawBackground(class GC gc, class COLOR bgcolor)
{
if (drawable)
{
# draw the background rectangle
gc.SetColorRGB(bgcolor.red, bgcolor.green, bgcolor.blue, 100);
gc.FillRect(0, 0, getWidth(), getHeight());
}
}
# draw the axes for the graph - dataMinZ == MAX_NUMBER and dataMaxZ == -MAX_NUMBER are displayed as null
proc drawGraphAxes(class GC gc, numeric distance, string xAxisLabel, string yAxisLabel, numeric drawTwoPointLines, class COLOR axiscolor, numeric fontHeight, numeric axisLabelOffset)
{
if (drawable)
{
# set the axis colors
gc.SetColorRGB(axiscolor.red, axiscolor.green, axiscolor.blue, 100);
# set the min and max display variables
local string min$ = sprintf("%0.2f", graphMinZ);
local string max$ = sprintf("%0.2f", graphMaxZ);
if (graphMaxZ==-MAX_NUMBER) max$ = "null";
if (graphMinZ==MAX_NUMBER) min$ = "null";
# Draw text for coordinate and elevation axis labels
gc.DrawTextSetFont("ARIAL");
gc.DrawTextSetHeightPixels(fontHeight);
# Draw graph axes
if (graphMaxZ == graphMinZ) max$ = "";
local array numeric graphx[3], graphy[3];
graphx[1] = leftGraphOffset;
graphy[1] = topGraphOffset;
graphx[2] = leftGraphOffset;
graphy[2] = getHeight() - bottomGraphOffset;
graphx[3] = getWidth() - rightGraphOffset;
graphy[3] = graphy[2];
gc.DrawPolyLine(graphx, graphy, 3);
# draw y axis labels
gc.TextStyle.Smoothing = 1;
gc.DrawTextSimple(max$, 2, graphy[1]+fontHeight/2);
gc.DrawTextSimple(min$, 2, graphy[2]+fontHeight/2);
gc.DrawTextSimple(yAxisLabel, graphx[1]-axisLabelOffset, (graphy[3]-graphy[1])/2+gc.TextGetWidth(yAxisLabel)*1.5, 90);
# draw x axis labels
gc.DrawTextSimple("0", graphx[1] - gc.TextGetWidth("0")/2, getHeight()-3);
local string str$ = sprintf("%0.2f", distance);
gc.DrawTextSimple(str$, getWidth() - gc.TextGetWidth(str$), getHeight()-3);
gc.DrawTextSimple(xAxisLabel, (graphx[3]-graphx[1])/2-gc.TextGetWidth(xAxisLabel)/4, graphy[3]+fontHeight+axisLabelOffset);
}
}
# Translate a point on the graphline to image device coordinates for drawing
func class POINT2D transPointToGraph(class POINT2D point, class POLYLINE graphLine)
{
local class POINT2D retpoint;
if (trans!=0) retpoint = trans.ConvertPoint2DFwd(point);
# copy the point
# local class POINT2D retpoint;
# retpoint = point;
#
# # get graph extents
# local numeric minx, maxx, miny, maxy;
# minx = leftGraphOffset;
# miny = topGraphOffset;
# maxx = getWidth() - rightGraphOffset;
# maxy = getHeight() - bottomGraphOffset;
#
# # Get the drawing scale
# local numeric xscale = 0, yscale = 0;
# xscale = (maxx - minx) / abs(graphLine.GetVertex(graphLine.GetNumPoints()-1).x - graphLine.GetVertex(0).x);
# if (graphMaxZ != graphMinZ) yscale = (maxy - miny) / (graphMaxZ - graphMinZ);
#
# # apply scales and offsets
# retpoint.x = point.x * xscale + leftGraphOffset;
# if (yscale!=0) retpoint.y = getHeight() - ((point.y-graphMinZ) * yscale + bottomGraphOffset);
# else retpoint.y = getHeight() - bottomGraphOffset;
return retpoint;
}
# Plot the vertex and any connecting lines in the graphLine
# (note: this method is a bit more clever as it doesn't translate a point more than once
# but is not being used currently - it does make drawPolyline a bit less clear however).
proc plotLine(class GC gc, class POLYLINE graphLine, numeric vertexNum)
{
local class POINT2D linePoint, graphPoint;
linePoint = graphLine.GetVertex(vertexNum);
graphPoint = transPointToGraph(linePoint, graphLine);
if (0)#!isConsecutive(graphLine, vertexNum))
{
# if not consecutive, finish drawing and move to next
gc.DrawTo(graphPoint.x, graphPoint.y);
linePoint = graphLine.GetVertex(vertexNum+1);
graphPoint = transPointToGraph(linePoint, graphLine);
gc.MoveTo(graphPoint.x, graphPoint.y);
}
else if (isNull(linePoint.y))
{
# if null skip point and move to next
linePoint = graphLine.GetVertex(vertexNum+1);
graphPoint = transPointToGraph(linePoint, graphLine);
gc.MoveTo(graphPoint.x, graphPoint.y);
}
else
{
gc.DrawTo(graphPoint.x, graphPoint.y);
}
}
# draw a two point line from the polyline p
proc drawLineSegment(class POLYLINE p, numeric vertex1, numeric vertex2, class COLOR color)
{
local class POINT2D point1, point2;
point1 = p.GetVertex(vertex1);
point2 = p.GetVertex(vertex2);
if (isNull(point1.y)||isNull(point2.y))
{
# if null skip point and move to next
point2 = transPointToGraph(point2, p);
gc.MoveTo(point2.x, point2.y);
}
else
{
point1 = transPointToGraph(point1, p);
point2 = transPointToGraph(point2, p);
gc.SetColorRGB(color.red, color.green, color.blue, 100);
gc.MoveTo(point1.x, point1.y);
gc.DrawTo(point2.x, point2.y);
}
}
# Draw the graph with the given polyline (not used currently - use with plotLine)
proc drawPolyline2(class GC gc, class POLYLINE graphLine, class COLOR lineColor)
{
if (drawable && graphLine.GetNumPoints()>0)
{
# Draw the profile
gc.SetColorRGB(lineColor.red, lineColor.green, lineColor.blue, 100);
local class POINT2D linePoint = graphLine.GetVertex(0);
# Plot point zero
local class POINT2D graphPoint = transPointToGraph(linePoint, graphLine);
gc.DrawPoint(graphPoint.x, graphPoint.y);
# Plot the rest of the points - connecting them as lines
local numeric i;
for (i=0; i<graphLine.GetNumPoints(); i++)
{
plotLine(gc, graphLine, i);
}
}
}
# Draw the graph with the given polyline
proc drawPolyline1(class GC gc, class POLYLINE graphLine, class COLOR lineColor)
{
if (drawable && graphLine.GetNumPoints()>0)
{
# Plot the polyline one segment at a time
local numeric i;
for (i=0; i<graphLine.GetNumPoints()-1; i++)
{
drawLineSegment(graphLine, i, i+1, lineColor);
}
}
}
# Draw the graph with the given polyline
proc drawPolyline(class GC gc, class POLYLINE graphLine, class COLOR lineColor)
{
# Create a copy
local class POLYLINE line = graphLine;
line.ConvertForwardAffine(trans);
# Set the line color
gc.SetColorRGB(lineColor.red, lineColor.green, lineColor.blue, 100);
# Draw it with gc method
gc.DrawPolyLine2(line);
}
# Draw the graph with the given polyline as rectangles
# It is assumed that numPoints%5 = 0 (i.e. all rectangles are closed)
proc drawRectangles(class GC gc, class POLYLINE graphLine, class COLOR lineColor, class COLOR fillColor, numeric doFill)
{
local class POLYLINE rectangle;
if (drawable && graphLine.GetNumPoints()>=5)
{
local numeric i;
for (i=0; i<graphLine.GetNumPoints(); i=i+5)
{
# Extract the rectangle and convert to graph coords
graphLine.Extract(i, 5,rectangle); # extract 5 pts (making up the closed rectangle)
rectangle.ConvertForwardAffine(trans);
# Set the line color
gc.SetColorRGB(lineColor.red, lineColor.green, lineColor.blue, 100);
gc.DrawPolyLine2(rectangle);
# Set the fill color
if (doFill)
{
gc.SetColorRGB(fillColor.red, fillColor.green, fillColor.blue, 100);
gc.FillPolyLine2(rectangle);
}
}
}
}
# Draw the names of the manholes
proc drawManholeNames(class GC gc, class POLYLINE surface, class STRINGLIST manholeNames, class COLOR textColor, string font, numeric pixelFontHeight)
{
if (drawable && surface.GetNumPoints()>0)
{
gc.DrawTextSetFont(font);
gc.DrawTextSetHeightPixels(pixelFontHeight);
gc.DrawTextSetColors(textColor);
# Draw all the manhole names at the manhole tops
local numeric i;
for (i=0; i<surface.GetNumPoints(); i++)
{
# get the position
local class POINT2D linePoint = surface.GetVertex(i);
if(!isNull(linePoint.y))
{
local class POINT2D topPoint = transPointToGraph(linePoint, surface);
# draw the label
string name = manholeNames.GetString(i);
gc.TextStyle.Smoothing = 1;
gc.DrawTextSimple(name, topPoint.x + pixelFontHeight, topPoint.y - 3, 90);
}
}
}
}
# Draw the graph with the given polyline
proc drawManholes(class GC gc, class POLYLINE bottomLine, class POLYLINE surface, class COLOR lineColor)
{
if (drawable && bottomLine.GetNumPoints()>0 && surface.GetNumPoints()>0)
{
# Draw the profile
gc.SetColorRGB(lineColor.red, lineColor.green, lineColor.blue, 100);
# Plot the rest of the points - connecting them as lines
local numeric i;
for (i=0; i<bottomLine.GetNumPoints(); i++)
{
local class POINT2D linePoint = bottomLine.GetVertex(i);
local class POINT2D bottomPoint = transPointToGraph(linePoint, bottomLine);
linePoint = surface.GetVertex(i);
local class POINT2D topPoint = transPointToGraph(linePoint, bottomLine);
# do the drawing
gc.MoveTo(bottomPoint.x, topPoint.y);
gc.DrawTo(bottomPoint.x, bottomPoint.y);
}
}
}
# Determine if the grid should be drawn or not
func doDrawGrid()
{
return gridToggle.GetValue();
}
# Get the interval value for the x-dimension of the grid
func getGridIntervalX()
{
# get the value entry then round or set appropriately
local numeric xspacing = gridIntervalX.GetValue();
if (abs(xspacing)<1)
{
xspacing=xspacing/abs(xspacing);
gridIntervalX.SetValue(xspacing, 0);
}
else
{
xspacing = round(xspacing);
gridIntervalX.SetValue(xspacing, 0);
}
return xspacing;
}
# Get the interval value for the y-dimension of the grid
func getGridIntervalY()
{
# get the value entry then round or set appropriately
local numeric yspacing = gridIntervalY.GetValue();
if (abs(yspacing)<1)
{
yspacing=yspacing/abs(yspacing);
gridIntervalY.SetValue(yspacing, 0);
}
else
{
yspacing = round(yspacing);
gridIntervalY.SetValue(yspacing, 0);
}
return yspacing;
}
# Draw the grid
proc drawGrid(class GC gc, numeric xspacing, numeric yspacing, class POLYLINE bottomLine, class COLOR color)
{
if (doDrawGrid() && drawable && bottomLine.GetNumPoints()>1)
{
# set the grid color
gc.SetColorRGB(color.red, color.green, color.blue, 100);
local class POINT2D pt1, pt2;
# draw vertical lines
local numeric length = bottomLine.GetVertex(bottomLine.GetNumPoints()-1).x;
local class POINT2D bottomPoint;
local class POINT2D topPoint;
bottomPoint.y = graphMinZ;
topPoint.y = graphMaxZ;
for (bottomPoint.x = topPoint.x = xspacing; bottomPoint.x<=length; topPoint.x = bottomPoint.x = bottomPoint.x + xspacing)
{
# get graph coordinates
local class POINT2D graphBottomPoint = transPointToGraph(bottomPoint, bottomLine);
local class POINT2D graphTopPoint = transPointToGraph(topPoint, bottomLine);
# do the drawing
gc.MoveTo(graphTopPoint.x, graphTopPoint.y);
gc.DrawTo(graphBottomPoint.x, graphBottomPoint.y);
}
# draw horizontal lines
bottomPoint.x = 0;
topPoint.x = length;
bottomPoint.y = topPoint.y = graphMinZ;
for (bottomPoint.y = topPoint.y = ceil(graphMinZ); bottomPoint.y<=graphMaxZ; topPoint.y = bottomPoint.y = bottomPoint.y + yspacing)
{
# get graph coordinates
local class POINT2D graphBottomPoint = transPointToGraph(bottomPoint, bottomLine);
local class POINT2D graphTopPoint = transPointToGraph(topPoint, bottomLine);
# do the drawing
gc.MoveTo(graphTopPoint.x, graphTopPoint.y);
gc.DrawTo(graphBottomPoint.x, graphBottomPoint.y);
}
}
}
# Convert the polyline from obj to map coordinates
func class POLYLINE convertObjectToMap(class POLYLINE line)
{
local class POLYLINE ret;
local class POINT2D obj, map;
local numeric i;
# loop through the lines and convert from object to map coords
for (i=0; i<line.GetNumPoints(); i++)
{
obj = line.GetVertex(i);
map = ObjectToMap(lineVector, obj.x, obj.y, vecGeoref);
ret.AppendVertex(map);
}
return ret;
}
# Determine if the polyline needs to be reversed
# (based on the start and end nodes of the lines)
func needToReverseLine(class POLYLINE origLine, class POLYLINE newLine, first, last)
{
local class POINT2D point1, point2;
# no reversal append to end - check first to avoid unnecessary flip (S2==E1)
point1 = origLine.GetVertex(last);
point2 = newLine.GetVertex(0);
if (point1==point2) return 0;
# no reversal append to front - check first to avoid unnecessary flip (S1==E2)
point1 = origLine.GetVertex(first);
point2 = newLine.GetVertex(newLine.GetNumPoints()-1);
if (point1==point2) return 0;
# reverse the new line (line2) for append to end (E1==E2)
point1 = origLine.GetVertex(last);
point2 = newLine.GetVertex(newLine.GetNumPoints()-1);
if (point1==point2) return 1;
# reverse the new line for append to front (S1==S2)
point1 = origLine.GetVertex(first);
point2 = newLine.GetVertex(0);
if (point1==point2) return 1;
# no reversal - all disjoint cases
return 0;
}
# return 1 if should append polyline to end of line, 2 if should append polyline to front of line, 0 for no append
func doAppendEndPoints(class POINT2D start1, class POINT2D end1, class POINT2D start2, class POINT2D end2)
{
if(end1 == start2) return 1;
else if (end2 == start1) return 2;
else return 0;
}
# return 1 if should append polyline to end of line, 2 if should append polyline to front of line, 0 for no append
func doAppend(class POLYLINE line, class POLYLINE polyline)
{
class POINT2D lineStart = line.GetVertex(0);
class POINT2D lineEnd = line.GetVertex(line.GetNumPoints()-1);
class POINT2D polylineStart = polyline.GetVertex(0);
class POINT2D polylineEnd = polyline.GetVertex(polyline.GetNumPoints()-1);
return doAppendEndPoints(lineStart, lineEnd, polylineStart, polylineEnd);
}
# append the 'lineToAdd' to the 'line'
proc appendLine(class POLYLINE line, numeric newLine, numeric twoPointLine, numeric orderElements)
{
# Get the line as a polyline
local class POLYLINE polyline;
polyline = GetVectorLine(lineVector, newLine);
polyline = convertObjectToMap(polyline);
if (twoPointLine)
{
if (polyline.GetNumPoints()>2) polyline.Straighten();
}
# if this is the first line just append and return
if (line.GetNumPoints()==0)
{
line.Append(polyline);
if (orderElements) orderedElemList.AddToFront(NumToStr(newLine));
return;
}
# Check to see if we need to reverse the polyline
local numeric reverse = needToReverseLine(line, polyline, 0, line.GetNumPoints()-1);
if (reverse==1)
{
polyline.Reverse();
reversedList.SetString("1", indexOf(elemList ,newLine));
}
# now simply append the line
if (doAppend(line, polyline)==1)
{
# append to end
line.Append(polyline);
if (orderElements) orderedElemList.AddToEnd(NumToStr(newLine));
}
else if (doAppend(line, polyline)==2)
{
# append to front
polyline.Append(line);
line.Clear();
line.Append(polyline);
if (orderElements) orderedElemList.AddToFront(NumToStr(newLine));
}
else
{
# can occur if loop is made, should clear selection
PopupMessage("Cannot append disjoint line");
}
}
# set the global graph offsets
proc setGraphOffsets(class GC gc, numeric fontHeight, numeric axisLabelOffset)
{
# set the min and max display variables
local string min$ = sprintf("%0.2f", graphMinZ);
local string max$ = sprintf("%0.2f", graphMaxZ);
if (graphMaxZ==-MAX_NUMBER) max$ = "null";
if (graphMinZ==MAX_NUMBER) min$ = "null";
# PopupMessage( sprintf("font height = %d", NumToStr(fontHeight) ) );
if (graphMaxZ == graphMinZ) max$ = "";
local numeric size = max(gc.TextGetWidth(max$), gc.TextGetWidth(min$));
# PopupMessage( sprintf("max$ width = %d, min$ width = %d, size = %d", gc.TextGetWidth(max$), gc.TextGetWidth(min$), size) );
size = max(size, fontHeight+axisLabelOffset);
leftGraphOffset = size - 4;
# PopupMessage( sprintf("size = %d, height+offset = %d, leftGraphOffset = %d", size, fontHeight+axisLabelOffset, leftGraphOffset) );
}
# Procedure used to draw the graph; passed a special GC
# created by the following procedure.
proc drawGraph()
{
# save pipe top and bottom for highlighting
pipeBottomSave = pipeBottom;
pipeTopSave = pipeTop;
pipeFaceSave = pipeFace;
# create graphics context for graph
createGC();
gc.DrawTextSetFont("ARIAL");
local class COLOR color;
# set up the affine transformation for the graph
setTrans(pipeBottom);
# set up graph axes
local string xlabel = "Distance (m)";
local string ylabel = "Elevation (m)";
local numeric drawTwoPointLines = 0;
local numeric drawStartEndPoints = 1;
# set the graph offsets - (globals)
local numeric fontHeight = 12, axisLabelOffset = 3;
setGraphOffsets(gc, fontHeight, axisLabelOffset);
# fill in the background
local class COLOR bgcolor;
bgcolor.red = 98; bgcolor.green = 98; bgcolor.blue = 98;
drawBackground(gc, bgcolor);
# draw the grid
color.red = 80; color.green = 80; color.blue = 80;
drawGrid(gc, getGridIntervalX(), getGridIntervalY(), pipeBottom, color);
# Draw and label the axes
color.red = 0; color.green = 0; color.blue = 0;
drawGraphAxes(gc, pipeBottom.GetVertex(pipeBottom.GetNumPoints()-1).x, xlabel, ylabel, drawTwoPointLines, color, fontHeight, axisLabelOffset);
# draw the pipe bottom
color = vectorLayer.SelectedElemColor;
# drawPolyline(gc, pipeBottom, color);
# draw the pipe top
# drawPolyline(gc, pipeTop, color);
# draw the pipe face
local class COLOR fill = vectorLayer.SelectedElemColor;
# fill.red = 40; fill.green = 40; fill.blue = 80;
drawRectangles(gc, pipeFace, color, fill, fillToggle.GetValue());
# draw the surface line (as DEM or from DB)
class POLYLINE manholeSurfaceLine;
if (doUseDEM())
{
# draw smoothed DEM surface line
gc.DrawSetLineStyle("");
color.red = 0; color.green = 0; color.blue = 0;
drawPolyline(gc, smoothedSurface, color);
manholeSurfaceLine = demSurface;
}
else
{
# draw surface line
color.red = 0; color.green = 0; color.blue = 0;
drawPolyline(gc, surface, color);
manholeSurfaceLine = surface;
}
# draw the manholes
color.red = 20; color.green = 80; color.blue = 20;
drawManholes(gc, manholeDepth, manholeSurfaceLine, color);
# draw the manhole labels
color.red = 0; color.green = 0; color.blue = 0;
drawManholeNames(gc, manholeSurfaceLine, manholeNames, color, "ARIAL", 12);
canvas.Refresh(1); # refresh the drawing canvas
}
# Procedure for drawing graph in CAD object; passed a local GC
# when called by the OnSaveGraph() procedure
proc drawGraphForCAD(class GC gc)
{
local class COLOR color;
gc.DrawTextSetFont("ARIAL");
# set up the affine transformation for the graph
setTrans(pipeBottom);
# set up graph axes
local string xlabel = "Distance (m)";
local string ylabel = "Elevation (m)";
local numeric drawTwoPointLines = 0;
local numeric drawStartEndPoints = 1;
# set the graph offsets - (globals)
local numeric fontHeight = 12, axisLabelOffset=3;
setGraphOffsets(gc, fontHeight, axisLabelOffset);
# fill in the background
local class COLOR bgcolor;
bgcolor.red = 98; bgcolor.green = 98; bgcolor.blue = 98;
drawBackground(gc, bgcolor);
# draw the grid
color.red = 80; color.green = 80; color.blue = 80;
drawGrid(gc, getGridIntervalX(), getGridIntervalY(), pipeBottom, color);
# Draw and label the axes
color.red = 0; color.green = 0; color.blue = 0;
drawGraphAxes(gc, pipeBottom.GetVertex(pipeBottom.GetNumPoints()-1).x, xlabel, ylabel, drawTwoPointLines, color, fontHeight, axisLabelOffset);
# draw the pipe bottom
color = vectorLayer.SelectedElemColor;
# drawPolyline(gc, pipeBottom, color);
# draw the pipe top
# drawPolyline(gc, pipeTop, color);
# draw the pipe face
local class COLOR fill = vectorLayer.SelectedElemColor;
# fill.red = 40; fill.green = 40; fill.blue = 80;
drawRectangles(gc, pipeFace, color, fill, fillToggle.GetValue());
# draw the surface line (as DEM or from DB)
class POLYLINE manholeSurfaceLine;
if (doUseDEM())
{
# draw smoothed DEM surface line
gc.DrawSetLineStyle("");
color.red = 0; color.green = 0; color.blue = 0;
drawPolyline(gc, smoothedSurface, color);
manholeSurfaceLine = demSurface;
}
else
{
# draw surface line
color.red = 0; color.green = 0; color.blue = 0;
drawPolyline(gc, surface, color);
manholeSurfaceLine = surface;
}
# draw the manholes
color.red = 20; color.green = 80; color.blue = 20;
drawManholes(gc, manholeDepth, manholeSurfaceLine, color);
# draw the manhole labels
color.red = 0; color.green = 0; color.blue = 0;
drawManholeNames(gc, manholeSurfaceLine, manholeNames, color, "ARIAL", 12);
}
# Procedure called when Save Graph as CAD button on dialog is pressed
proc OnSaveGraph()
{
GetOutputCAD(CADgraph); # prompt user to select output CAD object
# create GREDEVICE for drawing into CAD object
deviceCAD.Create(CADgraph , getHeight(), getWidth() );
# create graphics context for the device
local class GC gcCAD;
gcCAD = deviceCAD.CreateGC();
# call procedure to draw the graph for the CAD object
drawGraphForCAD(gcCAD);
deviceCAD.Close(); # close CAD graphics device
CloseCAD(CADgraph); # close CAD object
}
# Called when the min or max z value is changed
proc OnChangeGraphZ()
{
graphMinZ = graphMinSetting.GetValue();
graphMaxZ = graphMaxSetting.GetValue();
needsRedraw = 1;
}
# Callback for a right mouse button press
proc OnRightButtonPress()
{
# make sure z settings are current
OnChangeGraphZ();
# clear the line
demLine.Clear();
orderedElemList.Clear();
# Get the first line as a polyline
class POLYLINE finalLine;
# Get all of the lines, appending appropriately
local numeric i;
for (i=0; i<elemList.GetNumItems(); i++)
{
appendLine(finalLine, getElement(elemList, i), 1, 1);
appendLine(demLine, getElement(elemList, i), 0, 0);
}
# Get the line to graph - x-dimension is distance, y is elevation
pipeBottom = constructPipeBottom(finalLine);
# Create the pipe top line - bottom + pipeHeight
pipeTop = constructPipeTop(pipeBottom, finalLine);
# Create the pipe face - defines the area between the pipeBottom and pipeTop
pipeFace = constructPipeFace(pipeBottom, pipeTop);
# Create the surface line
surface = constructSurface(finalLine);
# Create the manhole depth line
manholeDepth = constructManholeDepth(pipeBottom, finalLine);
# Create the manhole labels
manholeNames = constructManholeNames(finalLine);
# Create the dem surface line
if (doUseDEM() && demSet)
{
demSurface = constructDemSurface(demLine);
smoothedSurface = constructSmoothSurface(demLine, LinScale(dem), ColScale(dem), 3);
}
drawable = 1;
currentlyActive = -1;
drawGraph();
needsRedraw=0;
}
# Return a number > 0 if one of the two nodes matches an end node.
# case 1: node1==endNodes[1] return 1
# case 2: node1==endNodes[2] return 2
# case 3: node2==endNodes[1] return 3
# case 4: node2==endNodes[2] return 4
func matchesEndNodes(numeric node1, numeric node2)
{
if (node1==endNodes[1]) # S1 == S2
{
endNodes[1] = node2;
return 1;
}
if (node1==endNodes[2]) # E1 == S2
{
endNodes[2] = node2;
return 2;
}
if (node2==endNodes[1]) # S1 == E2
{
endNodes[1] = node1;
return 3;
}
if (node2==endNodes[2]) # E1 == E2
{
endNodes[2] = node1;
return 4;
}
return 0;
}
# if list has 0 -> 1 else -> 0
proc reverseBits(class STRINGLIST s)
{
local numeric i;
for (i=0; i<s.GetNumItems(); i++)
{
if (s.GetString(i)=="0") s.SetString("1", i);
else s.SetString("0", i);
}
}
# Toggle the line element given the element number
proc toggleClosestLineElement(numeric elemNum)
{
# check the endnodes for a match
local numeric node1 = lineVector.LINE[elemNum].Internal.StartNode;
local numeric node2 = lineVector.LINE[elemNum].Internal.EndNode;
local numeric index = indexOf(elemList, elemNum);
local numeric matchNum = matchesEndNodes(node1, node2);
if (index>=0)
{
local numeric doRemove = 0;
# check to see if the current line is removable
if (matchNum>0) doRemove = 1;
if (doRemove)
{
# remove the line
vectorLayer.Line.HighlightSingle(elemNum, "Subtract");
elemList.Remove(index);
reversedList.Remove(index);
if (reversedList.GetString(0)=="1") reverseBits(reversedList);
if(vectorLayer.Line.GetSelectedElement()==0)
{
endNodes[1] = -1;
endNodes[2] = -1;
}
}
}
else
{
# if no lines exist, then simply append
if (endNodes[1]==-1 && endNodes[2]==-1)
{
endNodes[1] = node1;
endNodes[2] = node2;
vectorLayer.Line.HighlightSingle(elemNum, "Add");
elemList.AddToEnd(NumToStr(elemNum));
reversedList.AddToEnd("0");
}
else if (matchNum>0) # check to see if the current line is appendable
{
# add the line
vectorLayer.Line.HighlightSingle(elemNum, "Add");
elemList.AddToEnd(NumToStr(elemNum));
reversedList.AddToEnd("0");
}
}
}
# Toggle the line element closest to the point 'position'
func toggleClosestLine(class POINT2D position)
{
local numeric elemNum = FindClosestLine(lineVector, position.x, position.y);
if (elemNum > 0 )
{
toggleClosestLineElement(elemNum);
}
return elemNum;
}
# Callback for a left mouse button press
proc OnLeftButtonPress()
{
# Find cursor position in screen coordinates
local class POINT2D point;
point.x = PointerX;
point.y = PointerY;
point = TransPoint2D(point, ViewGetTransLayerToScreen(View, vectorLayer, 1));
# toggle the element as selected (if valid) or deselected (if possible)
toggleClosestLine(point);
}
# Called when the close button is pressed. Closes the dialogs.
proc cbClose()
{
dlgwin.Close(0);
if (setDefaultWhenClose)
{
setDefaultWhenClose = false;
View.SetDefaultTool();
}
}
# Called when the canvas is resized - gc is recreated before drawing
proc OnCanvasResize(class GUI_CANVAS canvas, numeric width, numeric height)
{
OnRightButtonPress();
}
# return the element number of the nearest line to the graph point
func getNearestLineElementFromGraph(class POINT2D graphPoint)
{
# make sure z settings are current
# graphMinZ = graphMinSetting.GetValue();
# graphMaxZ = graphMaxSetting.GetValue();
local class POLYLINE splits;
local class POINT2D tmp;
local numeric distance = 0;
tmp.x = distance;
tmp.y = 0;
splits.AppendVertex(tmp);
local numeric i=0;
for (i=1; i<finalLine.GetNumPoints(); i++)
{
local class POINT2D point1, point2;
point1 = finalLine.GetVertex(i-1);
point2 = finalLine.GetVertex(i);
local numeric dx = computeDistance(point1, point2);
distance += dx;
tmp.x = distance;
tmp.y = 0;
splits.AppendVertex(tmp);
}
local class RECT rect = getGraphExtents();
# Get the drawing scale
local numeric xscale = 0;
xscale = (rect.x2 - rect.x1) / distance;
# apply scales and offsets to get graph coords
for (i=1; i<splits.GetNumPoints(); i++)
{
tmp = splits.GetVertex(i);
tmp.x = tmp.x * xscale + leftGraphOffset;
splits.SetVertex(i, tmp);
}
graphPoint.y = 0; # ignore y axis
local numeric vertexNum = splits.FindClosestVertex(graphPoint);
tmp = splits.GetVertex(vertexNum);
# take care of duplicate vertex locations (which will choose first one)
if (graphPoint.x > tmp.x)
{
vertexNum++;
}
if (vertexNum >= splits.GetNumPoints() || (vertexNum==1 && graphPoint.x < leftGraphOffset))
{
return 0;
}
# get the line from the vertex
local numeric lineNum = floor(vertexNum/2);
local numeric elemNum = getElement(orderedElemList, lineNum);
# vertexDisplay.SetValue(vertexNum, 0);
# lineDisplay.SetValue(lineNum, 0);
# elemDisplay.SetValue(elemNum, 0);
return elemNum;
}
proc highlightGraphSegment(numeric lineNum, class COLOR color)
{
local class POLYLINE myrect;
pipeFaceSave.Extract(lineNum*5, 5, myrect);
drawRectangles(gc, myrect, color, color, fillToggle.GetValue());
# draw the manholes
color.red = 20; color.green = 80; color.blue = 20;
drawManholes(gc, pipeBottomSave, pipeTopSave, color);
canvas.Refresh(1);
}
proc makeLineActive(numeric elemNum)
{
vectorLayer.Line.SetActiveElement(elemNum);
local numeric lineOrdering = indexOf(orderedElemList, elemNum);
if (lineOrdering>-1 && currentlyActive != lineOrdering)
{
local class COLOR color = vectorLayer.SelectedElemColor;
if(currentlyActive>-1) highlightGraphSegment(currentlyActive, color);
currentlyActive = lineOrdering;
#color.red = 90; color.green = 90; color.blue = 100;
#highlightGraphSegment(currentlyActive, color);
color = vectorLayer.ActiveElemColor;
highlightGraphSegment(currentlyActive, color);
materialDisplay.SetValue(readLineTableRecordStr(elemNum, "CAN_MAT"), 0);
slopeDisplay.SetValue(readLineTableRecord(elemNum, "CAN_SLOPE"), 0);
diameterDisplay.SetValue(readLineTableRecord(elemNum, "CAN_DIAM")/1000, 0);
}
}
func getNearestLineElementFromGraph2(class POINT2D graphPoint)
{
# make sure z settings are current
# graphMinZ = graphMinSetting.GetValue();
# graphMaxZ = graphMaxSetting.GetValue();
local class POLYLINE splits = pipeBottomSave;
local class POINT2D tmp;
# local numeric distance = 0;
# tmp.x = distance;
# tmp.y = 0;
# splits.AppendVertex(tmp);
#
# local numeric i=0;
# for (i=1; i<finalLine.GetNumPoints(); i++)
# {
# local class POINT2D point1, point2;
# point1 = finalLine.GetVertex(i-1);
# point2 = finalLine.GetVertex(i);
# local numeric dx = computeDistance(point1, point2);
# distance += dx;
#
# tmp.x = distance;
# tmp.y = 0;
# splits.AppendVertex(tmp);
# }
#
# local class RECT rect = getGraphExtents();
#
# # Get the drawing scale
# local numeric xscale = 0;
# xscale = (rect.x2 - rect.x1) / distance;
# apply scales and offsets to get graph coords
local numeric i;
for (i=1; i<splits.GetNumPoints(); i++)
{
# tmp = splits.GetVertex(i);
# tmp.x = tmp.x * xscale + leftGraphOffset;
tmp = trans.ConvertPoint2DFwd(splits.GetVertex(i));
tmp.y = 0;
splits.SetVertex(i, tmp);
}
graphPoint.y = 0; # ignore y axis
local numeric vertexNum = splits.FindClosestVertex(graphPoint);
tmp = splits.GetVertex(vertexNum);
# take care of duplicate vertex locations (which will choose first one)
if (graphPoint.x > tmp.x)
{
vertexNum++;
}
if (vertexNum >= splits.GetNumPoints() || (vertexNum==1 && graphPoint.x < leftGraphOffset))
{
return 0;
}
# get the line from the vertex
local numeric lineNum = floor(vertexNum/2);
local numeric elemNum = getElement(orderedElemList, lineNum);
# vertexDisplay.SetValue(vertexNum, 0);
# lineDisplay.SetValue(lineNum, 0);
# elemDisplay.SetValue(elemNum, 0);
return elemNum;
}
# Called when the mouse is moved over the canvas - highlights the nearest line in the 2d view
proc OnCanvasMouseMove(class GUI_CANVAS canvas, class POINT2D point, numeric shift, numeric ctrl)
{
#<debug>
local class POINT2D mapPoint = trans.ConvertPoint2DInv(point);
if (!IsNull(mapPoint.x) && !IsNull(mapPoint.y))
{
mouseXDisplay.SetValue(mapPoint.x,0);
mouseYDisplay.SetValue(mapPoint.y,0);
}
#</debug>
if (needsRedraw)
{
OnRightButtonPress();
}
local numeric elemNum = getNearestLineElementFromGraph(point);
if (elemNum > 0)
{
makeLineActive(elemNum);
}
needsRedraw = 0;
}
# Called when mouse is moved over the 2D view - highlights the nearest line in the 2d view
proc OnPointerMoveNoButton()
{
if (needsRedraw)
{
OnRightButtonPress();
needsRedraw = 0;
}
local class POINT2D pointer;
pointer.x = PointerX;
pointer.y = PointerY;
# Get the cursor position in map coords
local class TRANSPARM screenToView = ViewGetTransViewToScreen(View, 1);
local class TRANSPARM viewToLayer = ViewGetTransLayerToView(View, vectorLayer, 1);
pointer = TransPoint2D(pointer, screenToView);
pointer = TransPoint2D(pointer, viewToLayer);
local numeric elemNum = FindClosestLine(lineVector, pointer.x, pointer.y);
if (elemNum > 0)
{
makeLineActive(elemNum);
}
}
# Called when the button to clear the lines is pressed
proc OnClearLines()
{
endNodes[1]=-1;
endNodes[2]=-1;
elemList.Clear();
orderedElemList.Clear();
reversedList.Clear();
vectorLayer.UnhighlightAllElements(1);
materialDisplay.SetValue("", 0);
slopeDisplay.SetValue(0, 0);
diameterDisplay.SetValue(0, 0);
mouseXDisplay.SetValue(0, 0);
mouseYDisplay.SetValue(0, 0);
OnRightButtonPress();
}
# Called with the grid toggle button is pressed, does a full redraw
proc OnGridTogglePressed()
{
OnRightButtonPress();
}
# Called with the fill toggle button is pressed, does a full redraw
proc OnFillTogglePressed()
{
OnRightButtonPress();
}
# Called with the grid toggle button is pressed, checks that dem exists
proc OnDemTogglePressed()
{
checkLayer();
}
# Called the first time the tool is activated.
# If the tool implements a dialog it should be created (but not displayed) here.
func OnInitialize()
{
# initialize the end node values, used to validate line appends
endNodes[1]=-1;
endNodes[2]=-1;
# handle as layout or as group
if (Layout)
{
WidgetAddCallback(Layout.GroupSelectedCallback, cbGroup);
activegroup = Layout.ActiveGroup;
}
else activegroup = Group;
WidgetAddCallback(activegroup.LayerSelectedCallback, cbLayer);
# define the dialog here with xml specification
string xml$ =
'<?xml version="1.0"?>
<!DOCTYPE root SYSTEM "smlforms.dtd">
<root>
<dialog id="guicanvas" Title="Line Profile" Buttons="">
<groupbox Name=" Graph elevation display settings: " ExtraBorder="4" HorizResize="Fixed" VertResize="Fixed">
<pane Orientation="horizontal">
<togglebutton id="demtoggle" Name="Use DEM"/>
<pane ChildSpacing="0" VertAlign="Top">
<label>Minimum Z:</label>
<editnumber id="minz" BlankZero="false" Precision="0" ReadOnly="false" Width="5" Height="10" Default="0" OnChanged="OnChangeGraphZ()"/>
</pane>
<pane ChildSpacing="0" VertAlign="Bottom">
<label>Maximum Z:</label>
<editnumber id="maxz" BlankZero="false" Precision="0" ReadOnly="false" Width="5" Height="10" Default="25" OnChanged="OnChangeGraphZ()"/>
</pane>
</pane>
</groupbox>
<groupbox Name=" Grid display settings: " ExtraBorder="4" HorizResize="Fixed" VertResize="Fixed">
<pane Orientation="horizontal">
<togglebutton id="gridtoggle" Name="Draw Grid"/>
<pane ChildSpacing="0" VertAlign="Top">
<label>X-Interval:</label>
<editnumber id="xinterval" BlankZero="false" Precision="0" ReadOnly="false" Width="5" Height="10" Default="10"/>
</pane>
<pane ChildSpacing="0" VertAlign="Bottom">
<label>Y-Interval:</label>
<editnumber id="yinterval" BlankZero="false" Precision="0" ReadOnly="false" Width="5" Height="10" Default="1"/>
</pane>
</pane>
</groupbox>
<pane>
<canvas id="canvas" ExtraBorder="4" Width="400" Height="300"/>
</pane>
<groupbox Name=" Pipe Attributes: " ExtraBorder="4" HorizResize="Fixed" VertResize="Fixed">
<pane Orientation="horizontal" HorizAlign="Center">
<pane ChildSpacing="0" HorizAlign="Left">
<label>Pipe Material:</label>
<edittext id="material" ReadOnly="true" Width="5"/>
</pane>
<pane ChildSpacing="0" HorizAlign="Left">
<label>Pipe Diameter:</label>
<editnumber id="diameter" BlankZero="true" Precision="3" ReadOnly="true" Width="5" Height="10" Default="0"/>
<label>meters</label>
</pane>
<pane ChildSpacing="0" HorizAlign="Left">
<label>Pipe Slope:</label>
<editnumber id="slope" BlankZero="false" Precision="2" ReadOnly="true" Width="5" Height="10" Default="0"/>
</pane>
</pane>
</groupbox>
<pane Orientation="horizontal" HorizAlign="Center">
<groupbox Name=" Coordinate Display: " ExtraBorder="4" HorizResize="Fixed" VertResize="Fixed">
<pane Orientation="horizontal" HorizAlign="Center">
<pane ChildSpacing="0" HorizAlign="Left">
<label>Distance:</label>
<editnumber id="mousex" BlankZero="false" Precision="2" ReadOnly="true" Width="5" Height="10" Default="0" MinVal="0" />
</pane>
<pane ChildSpacing="0" HorizAlign="Left">
<label>Elevation:</label>
<editnumber id="mousey" BlankZero="false" Precision="2" ReadOnly="true" Width="5" Height="10" Default="0"/>
</pane>
</pane>
</groupbox>
<groupbox Name=" Pipe Style Settings: " ExtraBorder="4" HorizResize="Fixed" VertResize="Fixed">
<pane Orientation="horizontal">
<togglebutton id="filltoggle" Name="Fill Pipe Polygons"/>
</pane>
</groupbox>
</pane>
<!--
<pane Orientation="horizontal" HorizAlign="Center">
<pane ChildSpacing="0" HorizAlign="Left">
<label>VertexNum:</label>
<editnumber id="vertex" BlankZero="false" Precision="0" ReadOnly="true" Width="5" Height="10" Default="0"/>
</pane>
<pane ChildSpacing="0" HorizAlign="Left">
<label>LineNum:</label>
<editnumber id="line" BlankZero="false" Precision="0" ReadOnly="true" Width="5" Height="10" Default="0"/>
</pane>
<pane ChildSpacing="0" HorizAlign="Left">
<label>ElemNum:</label>
<editnumber id="elem" BlankZero="true" Precision="0" ReadOnly="true" Width="5" Height="10" Default="0"/>
</pane>
</pane>
-->
<pane Orientation="horizontal" HorizAlign="Center" HorizResize="Fixed" VertResize="Fixed">
<pushbutton id="clearlines" Name="Clear Selected Lines" OnPressed="OnClearLines()"/>
<pushbutton id="saveGraph" Name="Save Graph as CAD" OnPressed="OnSaveGraph()"/>
</pane>
</dialog>
</root>
';
# Parse the xml dialog specification
local class XMLDOC dlgdoc;
local numeric err = dlgdoc.Parse(xml$);
if (err < 0) {
PopupError(err);
Exit();
}
local string dlgid$ = "guicanvas";
local class XMLNODE dlgnode = dlgdoc.GetElementByID(dlgid$);
if (dlgnode == 0) {
PopupMessage("Could not find specified id: "+dlgid$);
Exit();
}
dlgwin.SetXMLNode(dlgnode);
# create the dialog as a modeless dialog
err = dlgwin.CreateModeless();
if (err < 0) {
PopupError(err);
Exit();
}
# get the control for the drawing canvas
canvas = dlgwin.GetCtrlByID("canvas");
canvas.SetOnSize(OnCanvasResize);
canvas.SetOnRightDown(OnCanvasResize);
canvas.SetOnMouseMove(OnCanvasMouseMove);
# get the control for the grid toggle
gridToggle = dlgwin.GetCtrlByID("gridtoggle");
gridToggle.SetValue(1,0);
gridToggle.SetOnPressed(OnGridTogglePressed);
# get the control for the dem toggle
demToggle = dlgwin.GetCtrlByID("demtoggle");
demToggle.SetOnPressed(OnDemTogglePressed);
# get the controls for the grid interval settings
gridIntervalX = dlgwin.GetCtrlByID("xinterval");
gridIntervalY = dlgwin.GetCtrlByID("yinterval");
# get the controls for the min and max z setting
graphMinSetting = dlgwin.GetCtrlByID("minz");
graphMaxSetting = dlgwin.GetCtrlByID("maxz");
OnChangeGraphZ();
# get the control for the grid toggle
fillToggle = dlgwin.GetCtrlByID("filltoggle");
fillToggle.SetValue(1,0);
fillToggle.SetOnPressed(OnFillTogglePressed);
# get control for display of info
# vertexDisplay = dlgwin.GetCtrlByID("vertex");
# lineDisplay = dlgwin.GetCtrlByID("line");
# elemDisplay = dlgwin.GetCtrlByID("elem");
mouseXDisplay = dlgwin.GetCtrlByID("mousex");
mouseYDisplay = dlgwin.GetCtrlByID("mousey");
materialDisplay = dlgwin.GetCtrlByID("material");
slopeDisplay = dlgwin.GetCtrlByID("slope");
diameterDisplay = dlgwin.GetCtrlByID("diameter");
drawable = 0;
}
# Called when tool is to be destroyed, will not be called if tool was never activated.
func OnDestroy()
{
dlgwin.Close(0);
}
# Called when tool is activated.
func OnActivate()
{
checkLayer();
# open the graph dialog window
dlgwin.Open();
# draw the graph
OnRightButtonPress();
setDefaultWhenClose = true;
}
# Called when tool is deactivated (usually when switching to another tool).
func OnDeactivate()
{
setDefaultWhenClose = false;
cbClose();
}
Download