PATHcALT.sml

######################
#
# PATHcALT.SML
#
# Demonstration of movie generation from 3D display using
# 2D vector objects to derive viewer position (flight) path 
# and path of view center.  Both 2D and 3D views are
# copied into each movie frame.  Current viewer position and
# view center positions are shown in each 2D frame.
#
# Script uses input DEM for surface, an input raster drape layer, and
# two input vector objects, each with a single line, one defining the
# ground trace of the viewer position and the other defining the ground
# trace of the view center.
#
# Computes constant-altitude flight path a set height
# above the highest surface elevation beneath the flight
# path.  View center moves on the surface. 
#
# Both paths are partitioned into equal segments to set 
# positions for capturing frames (to produce smoother motion).
# Symbols are drawn into each frame to mark current viewer and
# view center locations.
#
# Requires TNTmips Version 6.5
#
#####################

clear();

#### Set movie format, frame rate, and recording time

# Movie format (Possible values : "MPEG"(All platform) or "AVI"(Windows only) 
string format$;
format$ = "AVI";

# Frame rate 
# Possible values : 
#   "MOVIE_FRAMERATE_23_976"  23.976 (24000/1001) fps - NTSC encapsulated film rate
#   "MOVIE_FRAMERATE_24"		24 fps - Standard international cinema film rate
#   "MOVIE_FRAMERATE_25"   	25 fps - PAL (625/50) video frame rate
#   "MOVIE_FRAMERATE_29_970"  29.97 (30000/1001) fps - NTSC video frame rate
#   "MOVIE_FRAMERATE_30"   	30 fps - NTSC drop-frame (525/60) video frame rate
#   "MOVIE_FRAMERATE_50"   	50 fps - Double frame rate / progressive PAL
#   "MOVIE_FRAMERATE_59_940"  59.94 (60000/1001) fps - Double frame rate NTSC
#   "MOVIE_FRAMERATE_60"   	60 fps - Double frame rate drop-frame NTSC

string framerate$;
framerate$ = "MOVIE_FRAMERATE_24";

# Recording time
numeric time;
time = 60;

####### Get RVC objects to load
raster Surface, RastDrape;
vector FlightPathVec, ViewCenterVec;

print("Select raster to use for surface");
GetInputRaster(Surface);

print("Select raster to use for drape layer");
GetInputRaster(RastDrape);

print("Select 3D vector to use for flight path");
GetInputVector(FlightPathVec);

print("Select vector to use for view center path");
GetInputVector(ViewCenterVec);

###### RVC style object to draw center point and viewer point
string styleFilename$;
string styleObjectname$;
GetInputObject("Style","Select style object for center and viewer point symbols:", 
	styleFilename$, styleObjectname$);
string viewer$;
viewer$ = "VIEWER";
string center$;
center$ = "CENTER";

######## Create display group with 2d and 3d views

print("START");

# Size of squared 2D view and 3D view
# Should be evenly divisible by 8
numeric size;
size = 320;

# Zoom out factor for 2D view
numeric zoomfactor;
zoomfactor = 1.0;

# Create group
print("Creating Group");
class GRE_GROUP group;
group = GroupCreate();

# Create flags to create view without iconbar, scrollbars, status line and scale/position line
# This is important to maintain fixed window size for movie generation
string flags$;
flags$ = "NoScalePosLine,NoIconBar,NoScrollbars,NoStatusLine";

# Create dialog and 2D view
print("Creating dialog and 2D view");
class XmForm dialog2d;
class GRE_VIEW view2d;
dialog2d = CreateFormDialog("VIEW 2D");
view2d = GroupCreateView(group,dialog2d,"",size,size,flags$);
view2d.BackgroundColor.red = 67;
view2d.BackgroundColor.green = 100;
view2d.BackgroundColor.blue = 100;

# Create dialog and 3D view
print("Creating dialog and 3D view");
class XmForm dialog3d;
class GRE_VIEW3D view3d;
dialog3d = CreateFormDialog("VIEW 3D");
view3d = GroupCreate3DView(group,dialog3d,"",size,size,flags$);
view3d.BackgroundColor.red = 67;
view3d.BackgroundColor.green = 100;
view3d.BackgroundColor.blue = 100;

# Adding layers to group
GroupQuickAddRasterVar(group,Surface,1);
GroupQuickAddRasterVar(group,RastDrape,0);

# Open of both views
DialogOpen(dialog2d);
DialogOpen(dialog3d);

# Full redraw of both views
ViewRedrawFull(view2d);
ViewRedrawFull(view3d);
ViewZoomOut(view2d,zoomfactor,1);

####### Set up parameters for movie frame

# Destination of each view in final frame for movie 
numeric x2d, y2d, x3d, y3d, w, h;
x2d = 0;
y2d = 0;
x3d = size;
y3d = 0;
w = 2 * size;
h = size;

# Create text string for annotation in frame
string frameTitle$;
frameTitle$ = "Ray Mine, AZ";

# Font size for annotation in frame
numeric fontsize;
fontsize = 16;

# Define color for text annotation
class Color black;
black.red = 0;
black.green = 0;
black.blue = 0;

# Create frame
print("Creating frame for movie");
class Frame frame;
frame = FrameCreate(w,h);

# Create graphics context (GC) for frame
print("Creating GC for frame and activate it");
ActivateGC(FrameCreateGC(frame));
DrawTextSetHeightPixels(fontsize);
DrawUseStyleObject(styleFilename$,styleObjectname$);

######## Set some more movie parameters

# Initializing Movie
print("Initializing Movie");
class Movie movie;
movie = MovieInit();

# Check framerate and force it to "MOVIE_FRAMERATE_24" if it is invalid
numeric rate;
rate = 24;
if (framerate$ == "MOVIE_FRAMERATE_23_976") rate = 23.976;
if (framerate$ == "MOVIE_FRAMERATE_25") rate = 25.0;
if (framerate$ == "MOVIE_FRAMERATE_29_970") rate = 29.970;
if (framerate$ == "MOVIE_FRAMERATE_30") rate = 30.0;
if (framerate$ == "MOVIE_FRAMERATE_50") rate = 50.0; 
if (framerate$ == "MOVIE_FRAMERATE_59_940") rate = 59.940; 
if (framerate$ == "MOVIE_FRAMERATE_60") rate = 60.0;
if (rate == 24.0) framerate$ = "MOVIE_FRAMERATE_24";

# Set Movie Parameters
print("Setting Movie Parameters");
MovieSetFormat(movie,format$);
MovieSetFrameRate(movie,framerate$);
MovieSetFrameWidth(movie,w);
MovieSetFrameHeight(movie,h);

# Make Output File
string ext$;
ext$ = MovieGetFileExt(movie);
string filename$;
filename$ = GetOutputFileName("","Make filename for movie",ext$);
printf("Filename = %s\n",filename$);

# Check recording time
if (time <= 1.0) time = 1.0;

# Calculate number of frames
numeric numFrames = time * rate;

####### Get georeference parameters for layers and reset to group projection
####### (defined by raster drape layer)

# Georeference for surface layer
class Georef georefS;
georefS = GetLastUsedGeorefObject(Surface);
GeorefSetProjection(georefS,group.Projection);

# Georeference for flight path vector object
class Georef georefFlight;
georefFlight = GetLastUsedGeorefObject(FlightPathVec);
GeorefSetProjection(georefFlight,group.Projection);

# Georeference for view center path vector object
class Georef georefCent;
georefCent = GetLastUsedGeorefObject(ViewCenterVec);
GeorefSetProjection(georefCent,group.Projection);

####### Compute flight path from 2D vector line

# Create arrays of vertex coordinates for flight and center path lines
numeric numflight;	# number of vertices in flight path line
array numeric xarrayf [1];	# array to hold x-coordinates of flight line vertices
array numeric yarrayf [1];	# array to hold y-coordinates of flight line vertices

# Get x and y coordinates of line vertices
numflight = GetVectorLinePointList(FlightPathVec,xarrayf,yarrayf,1);

# Transform vertex coordinates for flight path to map coordinates for group
# and find surface Z-value for each vertex and maximum z-value

array numeric zarrayf [numflight];	# array to hold z-coordinates of flight line vertices

numeric obj_x;
numeric obj_y;
numeric map_x;
numeric map_y;

numeric maxZ;
maxZ =  0;

numeric i;
for i = 1 to numflight {
	obj_x = xarrayf[i];
	obj_y = yarrayf[i];
	ObjectToMap(FlightPathVec,obj_x,obj_y,georefFlight,map_x,map_y);
	xarrayf[i] = map_x;
	yarrayf[i] = map_y;
	MapToObject(georefS,map_x,map_y,Surface,obj_x,obj_y);
	zarrayf[i] = Surface[obj_y,obj_x];
	if (zarrayf[i] > maxZ) then maxZ = zarrayf[i];
	}

# Set desired altitude of flight path above maximum surface elevation
# on flight path
numeric clearance;
numeric altitude; 

clearance = 1000;
altitude = maxZ + clearance;

# Compute length of level flight path and movement increment
numeric dx;
numeric dy;
numeric dl;
numeric lengthf;		# flight path 2D length in meters
numeric incFlight;	# movement increment along flight path

lengthf = 0;

for i = 1 to (numflight - 1) {
	dx = xarrayf[i+1] - xarrayf[i];
	dy = yarrayf[i+1] - yarrayf[i];
	dl = sqrt( dx*dx + dy*dy );
	lengthf = lengthf + dl;
}

incFlight = lengthf / (numFrames - 1);

# Recalculate equal-distance vertices for flight path

array numeric xarrayf_eq [numFrames];	# array to hold x-coordinates of flight line vertices 
array numeric yarrayf_eq [numFrames]; # array to hold y-coordinates of flight line vertices
array numeric zarrayf_eq [numFrames]; # array to hold z-coordinates of flight line vertices

xarrayf_eq[1] = xarrayf[1];
yarrayf_eq[1] = yarrayf[1];
zarrayf_eq[1] = altitude;

numeric numvert_eq;
numeric indexf;
numeric coef;
numeric sum;
numeric rest;

numvert_eq = 1;
indexf = 1;
rest = 0.0;

while (numvert_eq < (numFrames - 1)) {
	dx = xarrayf[indexf+1] - xarrayf[indexf];
	dy = yarrayf[indexf+1] - yarrayf[indexf];
	dl = sqrt( dx*dx + dy*dy );
	rest = rest + dl;
	sum = 0.0;
	while ((rest > incFlight) and (numvert_eq < (numFrames - 1) ) ) {
		rest = rest - incFlight;
		sum = sum + incFlight;
		numvert_eq = numvert_eq + 1;
		coef = sum / dl;
		xarrayf_eq[numvert_eq] = xarrayf[indexf] + coef * dx;
		yarrayf_eq[numvert_eq] = yarrayf[indexf] + coef * dy;
		zarrayf_eq[numvert_eq] = altitude;
		}
	indexf = indexf + 1;
	}

xarrayf_eq[numFrames] = xarrayf[numflight];
yarrayf_eq[numFrames] = yarrayf[numflight];
zarrayf_eq[numFrames] = altitude;

##### Compute view center path from 2D vector line

# Create arrays to hold vertex x and y coordinates of view center line
# Arrays will be resized automatically by the GetVectorLinePointList function
numeric numcent;	# number of vertices in view center line

array numeric xarrayc [1];	# array to hold x-coordinates of center line vertices 
array numeric yarrayc [1]; # array to hold y-coordinates of center line vertices

# Get x and y coordinates of line vertices
numcent = GetVectorLinePointList(ViewCenterVec,xarrayc,yarrayc,1);

# Transform vertex coordinates for view center path to map coordinates for group
# and find surface Z-value for each vertex

array numeric zarrayc [numcent]; # array to hold z-coordinates of center line vertices

for i = 1 to numcent {
	obj_x = xarrayc[i];
	obj_y = yarrayc[i];
	ObjectToMap(ViewCenterVec,obj_x,obj_y,georefCent,map_x,map_y);
	xarrayc[i] = map_x;
	yarrayc[i] = map_y;
	MapToObject(georefS,map_x,map_y,Surface,obj_x,obj_y);
	zarrayc[i] = Surface[obj_y,obj_x];
	}

# Compute length of view center path and movement increment
numeric dz;
numeric lengthc;	# view center path 3D length in map meters
numeric incCent;	# movement increment along view center path

lengthc = 0;

for i = 1 to (numcent-1) {
	dx = xarrayc[i+1] - xarrayc[i];
	dy = yarrayc[i+1] - yarrayc[i];
	dz = zarrayc[i+1] - zarrayc[i];
	dl = sqrt( dx*dx + dy*dy + dz*dz );
	lengthc = lengthc + dl;
}

incCent = lengthc / numFrames ;

# Recalculate equal-distance vertices for center path

array numeric xarrayc_eq [numFrames]; # array to hold x-coordinates of center line vertices 
array numeric yarrayc_eq [numFrames]; # array to hold y-coordinates of center line vertices
array numeric zarrayc_eq [numFrames]; # array to hold z-coordinates of center line vertices

xarrayc_eq[1] = xarrayc[1];	# first vertex is the same for new path 
yarrayc_eq[1] = yarrayc[1];
zarrayc_eq[1] = zarrayc[1];

numeric numcent_eq;
numeric indexc;

numcent_eq = 1;
indexc = 1;
rest = 0.0;

while (numcent_eq < (numFrames - 1)) {
	dx = xarrayc[indexc+1] - xarrayc[indexc];
	dy = yarrayc[indexc+1] - yarrayc[indexc];
	dz = zarrayc[indexc+1] - zarrayc[indexc];
	dl = sqrt( dx*dx + dy*dy + dz*dz );
	rest = rest + dl;
	sum = 0.0;
	while ( (rest > incCent) and ( numcent_eq < (numFrames - 1) ) ) {
		rest = rest - incCent;
		sum = sum + incCent;
		numcent_eq = numcent_eq + 1;
		coef = sum / dl;
		xarrayc_eq[numcent_eq] = xarrayc[indexc] + coef * dx;
		yarrayc_eq[numcent_eq] = yarrayc[indexc] + coef * dy;
		zarrayc_eq[numcent_eq] = zarrayc[indexc] + coef * dz;
		}
	indexc = indexc + 1;
	}

xarrayc_eq[numFrames] = xarrayc[numcent];	# last vertex is the same also
yarrayc_eq[numFrames] = yarrayc[numcent];
zarrayc_eq[numFrames] = zarrayc[numcent];

##### Set up viewpoint and viewer position parameters
class VIEWPOINT3D vp;
vp = view3d.ViewPoint;

class POINT3D fpt;			# flight path location
class POINT3D cpt;			# center point location
class POINT2D point;			# 2D point for location symbols

##### Start recording movie to file
MovieStart(movie,filename$);

# Loop for each frame
for i = 1 to numFrames {
	SetStatusMessage(sprintf("Processing frame %d of %d",i,numFrames));

	# Set viewer position and center position and redraw views

	fpt.x = xarrayf_eq[i];
	fpt.y = yarrayf_eq[i];
	fpt.z = zarrayf_eq[i];
	vp.SetViewerPosition(fpt);

	cpt.x = xarrayc_eq[i];
	cpt.y = yarrayc_eq[i];
	cpt.z = zarrayc_eq[i];
	vp.SetCenter(cpt);

	# ViewRedrawDirect(view3d,"NoBlankScreen");
	# This new function	added after release of TNTmips 6.5
	# can redraw the view without blanking it first.  Use of
	# this function eliminates "flashing" of the view as the
	# movie is initially rendered.  It has no effect on the
	# output movie file.  For 6.5 release version, use the
	# function in the next statement.

	ViewRedraw(view3d);

	# Copy 2dd view and 3d view to destination frame
	FrameCopyFromView(frame,view2d,0,0,size,size,x2d,y2d);
	FrameCopyFromView(frame,view3d,0,0,size,size,x3d,y3d);

	# Draw center point in 2d frame
	point.x = vp.CenterPoint.x;
	point.y = vp.CenterPoint.y;
	point = TransPoint2D(point,ViewGetTransMapToView(view2d,group.Projection));
	point = TransPoint2D(point,ViewGetTransViewToScreen(view2d));
	DrawSetPointStyle(center$);
	DrawPoint(point.x,point.y);

	# Draw viewer position point in 2d frame
	point.x = vp.ViewPos.x;
	point.y = vp.ViewPos.y;
	point = TransPoint2D(point,ViewGetTransMapToView(view2d,group.Projection));
	point = TransPoint2D(point,ViewGetTransViewToScreen(view2d));
	DrawSetPointStyle(viewer$);
	DrawPoint(point.x,point.y);

	# Draw text to top of frame
	DrawTextSetColors(black);
	DrawTextSimple(frameTitle$,2,fontsize);

	# Add frame to movie
	MovieAddFrame(movie,frame);
}	# End of main processing loop

# Stop and Exit movie
MovieStop(movie);
MovieExit(movie);

# Close dialogs
DialogClose(dialog2d);
DialogClose(dialog3d);

print("END");