void
VisWinFrame::GetRange(double &min_x, double &max_x, double &min_y, double &max_y)
{
VisWindow *vw = mediator;
switch (vw->GetWindowMode())
{
case WINMODE_2D:
{
const avtView2D view2D = vw->GetView2D();
min_x = view2D.window[0];
max_x = view2D.window[1];
min_y = view2D.window[2];
max_y = view2D.window[3];
}
break;
case WINMODE_CURVE:
{
const avtViewCurve viewCurve = vw->GetViewCurve();
min_x = viewCurve.domain[0];
max_x = viewCurve.domain[1];
min_y = viewCurve.range[0];
max_y = viewCurve.range[1];
}
break;
default:
break;
}
}
void
FlyThrough::OnTimer(void)
{
vtkRenderWindowInteractor *rwi = Interactor;
int Pos[2];
rwi->GetEventPosition(Pos);
bool matchedUpState = true;
switch (State)
{
case VTKIS_ROTATE:
RotateAboutCamera3D(Pos[0], Pos[1]);
rwi->CreateTimer(VTKI_TIMER_UPDATE);
break;
case VTKIS_PAN:
PanCamera3D(Pos[0], Pos[1]);
rwi->CreateTimer(VTKI_TIMER_UPDATE);
break;
case VTKIS_ZOOM:
DollyCameraAndFocus3D(Pos[0], Pos[1]);
rwi->CreateTimer(VTKI_TIMER_UPDATE);
break;
default:
matchedUpState = false;
break;
}
if (!matchedUpState && shouldSpin)
{
VisWindow *vw = proxy;
if(!vw->GetSpinModeSuspended())
{
if (vw->GetSpinMode())
{
OldX = spinOldX;
OldY = spinOldY;
RotateAboutCamera3D(spinNewX, spinNewY);
rwi->CreateTimer(VTKI_TIMER_UPDATE);
}
else
{
DisableSpinMode();
}
}
else if(vw->GetSpinMode())
{
// Don't mess with the camera, just create another timer so
// we keep getting into this method until spin mode is no
// longer suspended.
rwi->CreateTimer(VTKI_TIMER_UPDATE);
}
}
}
void
Zoom3D::ZoomCamera(const int x, const int y)
{
if (OldY != y)
{
//
// Calculate the zoom factor.
//
double dyf = MotionFactor * (double)(y - OldY) /
(double)(Center[1]);
double zoomFactor = pow((double)1.1, dyf);
//
// Calculate the new parallel scale.
//
VisWindow *vw = proxy;
avtView3D newView3D = vw->GetView3D();
newView3D.imageZoom = newView3D.imageZoom * zoomFactor;
OldX = x;
OldY = y;
vw->SetView3D(newView3D);
}
}
NavigateAxisArray::NavigateAxisArray(VisWindowInteractorProxy &v) : VisitInteractor(v)
{
shiftKeyDown = controlKeyDown = false;
VisWindow *win = v;
shouldSnap = win->GetInteractorAtts()->GetAxisArraySnap();
axisOrientation = Vertical;
}
void
NavigateAxisArray::OnTimer(void)
{
vtkRenderWindowInteractor *rwi = Interactor;
int Pos[2];
rwi->GetEventPosition(Pos);
VisWindow *win = proxy;
shouldSnap = win->GetInteractorAtts()->GetAxisArraySnap();
switch (State)
{
case VTKIS_PAN:
PanCamera(Pos[0], Pos[1], shouldSnap);
rwi->CreateTimer(VTKI_TIMER_UPDATE);
break;
case VTKIS_DOLLY:
ZoomCamera(Pos[0], Pos[1]);
rwi->CreateTimer(VTKI_TIMER_UPDATE);
break;
default:
break;
}
}
// ****************************************************************************
// Method: RenderTranslucent
//
// Purpose: Renders translucent geometry within a VisWindow.
// Expects that opaque geometry has already been rendered. In the
// IceT case, our work is a lot simpler because we don't need to
// read the image back from the framebuffer (we'll read it back from
// IceT later anyway).
//
// Programmer: Tom Fogal
// Creation: August 4, 2008
//
// Modifications:
//
// ****************************************************************************
avtDataObject_p
IceTNetworkManager::RenderTranslucent(int windowID, const avtImage_p& input)
{
VisWindow *viswin = viswinMap.find(windowID)->second.viswin;
CallProgressCallback("IceTNetworkManager", "Transparent rendering", 0, 1);
{
StackTimer second_pass("Second-pass screen capture for SR");
//
// We have to disable any gradient background before
// rendering, as those will overwrite the first pass
//
AnnotationAttributes::BackgroundMode bm = viswin->GetBackgroundMode();
viswin->SetBackgroundMode(AnnotationAttributes::Solid);
viswin->ScreenRender(
this->r_mgmt.viewportedMode,
true, // Z buffer
false, // opaque geometry
true, // translucent geometry
input // image to composite with
);
// Restore the background mode for next time
viswin->SetBackgroundMode(bm);
}
CallProgressCallback("IceTNetworkManager", "Transparent rendering", 1, 1);
//
// In this implementation, the user should never use the return value --
// read it back from IceT instead!
//
return NULL;
}
void
VisWinInteractions::SetBoundingBoxMode(int val)
{
bboxMode = val;
bool doingBBox = false;
if (val == InteractorAttributes::Always)
doingBBox = true;
VisWindow *vw = mediator;
bool doingSR = vw->GetScalableRendering();
if (val == InteractorAttributes::Auto && doingSR)
doingBBox = true;
if (doingBBox)
{
// The continuous tool update mode does not
// work when bounding box mode is on.
if (toolUpdateMode == UPDATE_CONTINUOUS)
toolUpdateMode = UPDATE_ONRELEASE;
}
else
{
// The continuous tool update mode does
// work when bounding box mode is off.
if (toolUpdateMode == UPDATE_ONRELEASE)
toolUpdateMode = UPDATE_CONTINUOUS;
}
}
void
NavigateAxisArray::ZoomHorizontal(double f)
{
vtkRenderWindowInteractor *rwi = Interactor;
//
// Calculate the zoom factor.
//
double zoomFactor = pow((double)1.1, f);
//
// Calculate the new parallel scale.
//
VisWindow *vw = proxy;
avtViewAxisArray newViewAxisArray = vw->GetViewAxisArray();
double xDist = newViewAxisArray.domain[1] - newViewAxisArray.domain[0];
double dX = ((1. / zoomFactor) - 1.) * (xDist / 2.);
newViewAxisArray.domain[0] -= dX;
newViewAxisArray.domain[1] += dX;
vw->SetViewAxisArray(newViewAxisArray);
}
void
NavigateAxisArray::ZoomVertical(double f)
{
vtkRenderWindowInteractor *rwi = Interactor;
//
// Calculate the zoom factor.
//
double zoomFactor = pow((double)1.1, f);
//
// Calculate the new parallel scale.
//
VisWindow *vw = proxy;
avtViewAxisArray newViewAxisArray = vw->GetViewAxisArray();
double yDist = newViewAxisArray.range[1] - newViewAxisArray.range[0];
double dY = ((1. / zoomFactor) - 1.) * (yDist / 2.);
newViewAxisArray.range[0] -= dY;
newViewAxisArray.range[1] += dY;
vw->SetViewAxisArray(newViewAxisArray);
}
// ****************************************************************************
// Method: RenderGeometry
//
// Purpose: Renders the geometry for a scene; this is always the opaque
// objects, and may or may not include translucent objects (depending
// on the current multipass rendering settings).
// We override this method because we can avoid a readback in the
// one-pass case (we'll read it back from IceT later anyway).
//
// Programmer: Tom Fogal
// Creation: July 26, 2008
//
// Modifications:
//
// Tom Fogal, Mon Jul 28 14:57:01 EDT 2008
// Need to return NULL in the single-pass case!
//
// ****************************************************************************
avtImage_p
IceTNetworkManager::RenderGeometry()
{
VisWindow *viswin = viswinMap.find(this->r_mgmt.windowID)->second.viswin;
if(this->MemoMultipass(viswin))
{
return NetworkManager::RenderGeometry();
}
CallProgressCallback("IceTNetworkManager", "Render geometry", 0, 1);
viswin->ScreenRender(this->r_mgmt.viewportedMode, true);
CallProgressCallback("IceTNetworkManager", "Render geometry", 0, 1);
return NULL;
}
void
ZoomInteractor::StartRubberBand(int x, int y)
{
rubberBandMode = true;
shiftKeyDown = Interactor->GetShiftKey();
controlKeyDown = Interactor->GetControlKey();
VisWindow *win = proxy;
shouldClampSquare = win->GetInteractorAtts()->GetClampSquare();
shouldDrawGuides = win->GetInteractorAtts()->GetShowGuidelines();
// Set the actor's color.
double fg[3];
proxy.GetForegroundColor(fg);
rubberBandActor->GetProperty()->SetColor(fg[0], fg[1], fg[2]);
//
// Add the rubber band actors to the background. We do this since the
// background is in the same display coordinates that the rubber band will
// be. From an appearance standpoint it should be in the canvas, which
// the routine ForceCoordsToViewport ensures.
//
vtkRenderer *ren = proxy.GetBackground();
ren->AddActor2D(rubberBandActor);
//
// The anchor of the rubber band will be where the button press was.
//
anchorX = x;
anchorY = y;
//
// Determine what to clamp the rubber band to.
//
SetCanvasViewport();
//
// If the user has clicked outside the viewport, force the back inside.
//
ForceCoordsToViewport(anchorX, anchorY);
//
// Must update bookkeeping so that OnMouseMove works correctly.
//
lastX = anchorX;
lastY = anchorY;
rubberBandDrawn = false;
}
// ****************************************************************************
// Method: StopTimer
//
// Purpose: Time the IceT rendering process.
// IceT includes its own timing code that we might consider using at
// some point ...
//
// Programmer: Tom Fogal
// Creation: July 14, 2008
//
// Modifications:
//
// Hank Childs, Thu Jan 15 11:07:53 CST 2009
// Changed GetSize call to GetCaptureRegion, since that works for 2D.
//
// Tom Fogal, Fri May 29 20:37:59 MDT 2009
// Remove an unused variable.
//
// Burlen Loring, Tue Sep 1 14:26:30 PDT 2015
// sync up with network manager(base class) order compositing refactor
//
// ****************************************************************************
void
IceTNetworkManager::StopTimer()
{
char msg[1024];
VisWindow *viswin = renderState.window;
int rows,cols, width_start, height_start;
// This basically gets the width and the height.
// The distinction is for 2D rendering, where we only want the
// width and the height of the viewport.
viswin->GetCaptureRegion(width_start, height_start, rows,cols,
renderState.viewportedMode);
SNPRINTF(msg, 1023, "IceTNM::Render %lld cells %d pixels",
renderState.cellCountTotal, rows*cols);
visitTimer->StopTimer(renderState.timer, msg);
renderState.timer = -1;
}
// ****************************************************************************
// Method: StopTimer
//
// Purpose: Time the IceT rendering process.
// IceT includes its own timing code that we might consider using at
// some point ...
//
// Programmer: Tom Fogal
// Creation: July 14, 2008
//
// Modifications:
//
// Hank Childs, Thu Jan 15 11:07:53 CST 2009
// Changed GetSize call to GetCaptureRegion, since that works for 2D.
//
// Tom Fogal, Fri May 29 20:37:59 MDT 2009
// Remove an unused variable.
//
// ****************************************************************************
void
IceTNetworkManager::StopTimer(int windowID)
{
char msg[1024];
VisWindow *viswin = this->viswinMap.find(windowID)->second.viswin;
int rows,cols, width_start, height_start;
// This basically gets the width and the height.
// The distinction is for 2D rendering, where we only want the
// width and the height of the viewport.
viswin->GetCaptureRegion(width_start, height_start, rows,cols,
this->r_mgmt.viewportedMode);
SNPRINTF(msg, 1023, "IceTNM::Render %ld cells %d pixels",
GetTotalGlobalCellCounts(windowID), rows*cols);
visitTimer->StopTimer(this->r_mgmt.timer, msg);
this->r_mgmt.timer = -1;
}
void
VisWinFrame::UpdateView(void)
{
double min_x = 0., max_x = 0., min_y = 0., max_y = 0.;
GetRange(min_x, max_x, min_y, max_y);
//
// We put the topBorder in reverse so that its ticks would appear on the
// correct side of the viewport. Must propogate kludge by sending
// range in backwards.
//
leftBorder->SetRange(max_y, min_y);
leftBorder->SetUseOrientationAngle(1);
leftBorder->SetOrientationAngle(-1.5707963);
rightBorder->SetRange(min_y, max_y);
rightBorder->SetUseOrientationAngle(1);
rightBorder->SetOrientationAngle(1.5707963);
bottomBorder->SetRange(min_x, max_x);
bottomBorder->SetUseOrientationAngle(1);
bottomBorder->SetOrientationAngle(0.);
topBorder->SetRange(max_x, min_x);
topBorder->SetUseOrientationAngle(1);
topBorder->SetOrientationAngle(3.1415926);
VisWindow *vw = mediator;
bool logScale[2] = { false, false};
if (vw->GetWindowMode() == WINMODE_CURVE)
{
const avtViewCurve viewCurve = vw->GetViewCurve();
logScale[0] = viewCurve.domainScale == LOG;
logScale[1] = viewCurve.rangeScale == LOG;
}
else if (vw->GetWindowMode() == WINMODE_2D)
{
const avtView2D view2D = vw->GetView2D();
logScale[0] = view2D.xScale == LOG;
logScale[1] = view2D.yScale == LOG;
}
topBorder->SetLogScale((int)logScale[0]);
bottomBorder->SetLogScale((int)logScale[0]);
rightBorder->SetLogScale((int)logScale[1]);
leftBorder->SetLogScale((int)logScale[1]);
}
ZoomInteractor::ZoomInteractor(VisWindowInteractorProxy &vw)
: VisitInteractor(vw)
{
rubberBandMode = false;
shiftKeyDown = controlKeyDown = false;
VisWindow *win = vw;
shouldClampSquare = win->GetInteractorAtts()->GetClampSquare();
shouldDrawGuides = win->GetInteractorAtts()->GetShowGuidelines();
//
// Create the poly data that will map the rubber band onto the screen.
//
rubberBand = vtkPolyData::New();
vtkPoints *pts = vtkPoints::New();
#if defined(__APPLE__) || defined(_WIN32)
pts->SetNumberOfPoints(4);
rubberBand->SetPoints(pts);
pts->Delete();
vtkCellArray *lines = vtkCellArray::New();
vtkIdType ids[] = { 0, 1, 2, 3, 0};
lines->InsertNextCell(5, ids);
rubberBand->SetLines(lines);
lines->Delete();
#else
pts->SetNumberOfPoints(2);
rubberBand->SetPoints(pts);
pts->Delete();
vtkCellArray *lines = vtkCellArray::New();
vtkIdType ids[2] = { 0, 1 };
lines->InsertNextCell(2, ids);
rubberBand->SetLines(lines);
lines->Delete();
#endif
rubberBandMapper = proxy.CreateRubberbandMapper();
rubberBandMapper->SetInput(rubberBand);
rubberBandActor = vtkActor2D::New();
rubberBandActor->SetMapper(rubberBandMapper);
rubberBandActor->GetProperty()->SetColor(0., 0., 0.);
}
void
Navigate2D::PanCamera(const int x, const int y)
{
vtkRenderWindowInteractor *rwi = Interactor;
if ((OldX != x) || (OldY != y))
{
//
// Determine the size of the window.
//
int size[2];
rwi->GetSize(size);
//
// Get the current view information.
//
VisWindow *vw = proxy;
double viewport[4];
double pan[2];
avtView2D newView2D = vw->GetView2D();
newView2D.GetActualViewport(viewport, size[0], size[1]);
pan[0] = (double)(x - OldX) /
((viewport[1] - viewport[0]) * (double)(size[0])) *
(newView2D.window[1] - newView2D.window[0]);
pan[1] = (double)(y - OldY) /
((viewport[3] - viewport[2]) * (double)(size[1])) *
(newView2D.window[3] - newView2D.window[2]);
newView2D.window[0] -= pan[0];
newView2D.window[1] -= pan[0];
newView2D.window[2] -= pan[1];
newView2D.window[3] -= pan[1];
OldX = x;
OldY = y;
vw->SetView2D(newView2D);
}
}
void
NavigateCurve::PanCamera(const int x, const int y)
{
vtkRenderWindowInteractor *rwi = Interactor;
if ((OldX != x) || (OldY != y))
{
//
// Determine the size of the window.
//
int size[2];
rwi->GetSize(size);
//
// Get the current view information.
//
VisWindow *vw = proxy;
double pan[2];
avtViewCurve newViewCurve = vw->GetViewCurve();
pan[0] = (double)(x - OldX) /
((newViewCurve.viewport[1] - newViewCurve.viewport[0]) *
(double)(size[0])) *
(newViewCurve.domain[1] - newViewCurve.domain[0]);
pan[1] = (double)(y - OldY) /
((newViewCurve.viewport[3] - newViewCurve.viewport[2]) *
(double)(size[1])) *
(newViewCurve.range[1] - newViewCurve.range[0]);
newViewCurve.domain[0] -= pan[0];
newViewCurve.domain[1] -= pan[0];
newViewCurve.range[0] -= pan[1];
newViewCurve.range[1] -= pan[1];
vw->SetViewCurve(newViewCurve);
OldX = x;
OldY = y;
rwi->Render();
}
}
void
Zoom3D::EnableSpinMode(void)
{
VisWindow *vw = proxy;
if (vw->GetSpinMode())
{
shouldSpin = true;
//
// VTK will not be happy unless we enter one of its pre-defined modes.
// Timer seems as appropriate as any (there idea of spin is much
// different than ours). Also, set up the first timer so our spinning
// can get started.
//
StartTimer();
vtkRenderWindowInteractor *rwi = Interactor;
rwi->CreateTimer(VTKI_TIMER_UPDATE);
}
}
void
NavigateAxisArray::ZoomVerticalFixed(double f)
{
vtkRenderWindowInteractor *rwi = Interactor;
VisWindow *vw = proxy;
avtViewAxisArray newViewAxisArray = vw->GetViewAxisArray();
newViewAxisArray.range[0] -= f;
newViewAxisArray.range[1] += f;
if (newViewAxisArray.range[0] >= newViewAxisArray.domain[1])
{
newViewAxisArray.range[0] += f;
newViewAxisArray.range[1] -= f;
}
vw->SetViewAxisArray(newViewAxisArray);
}
void
VisWinAxesArray::GetRange(double &min_x, double &max_x,
double &min_y, double &max_y)
{
VisWindow *vw = mediator;
switch (vw->GetWindowMode())
{
case WINMODE_AXISARRAY:
{
const avtViewAxisArray viewAxisArray = vw->GetViewAxisArray();
min_x = viewAxisArray.domain[0];
max_x = viewAxisArray.domain[1];
min_y = viewAxisArray.range[0];
max_y = viewAxisArray.range[1];
}
break;
default:
break;
}
}
void
ZoomCurve::ZoomCamera(const int x, const int y)
{
vtkRenderWindowInteractor *rwi = Interactor;
if (OldY != y)
{
//
// Calculate the zoom factor.
//
double dyf = MotionFactor * (double)(y - OldY) /
(double)(Center[1]);
double zoomFactor = pow((double)1.1, dyf);
//
// Calculate the new window.
//
VisWindow *vw = proxy;
avtViewCurve newViewCurve = vw->GetViewCurve();
double dX = ((1. / zoomFactor) - 1.) *
((newViewCurve.domain[1] - newViewCurve.domain[0]) / 2.);
double dY = ((1. / zoomFactor) - 1.) *
((newViewCurve.range[1] - newViewCurve.range[0]) / 2.);
newViewCurve.domain[0] -= dX;
newViewCurve.domain[1] += dX;
newViewCurve.range[0] -= dY;
newViewCurve.range[1] += dY;
vw->SetViewCurve(newViewCurve);
OldX = x;
OldY = y;
rwi->Render();
}
}
void
NavigateCurve::ZoomCamera(double f)
{
double zoomFactor = pow((double)1.1, f);
//
// Calculate the new parallel scale.
//
VisWindow *vw = proxy;
avtViewCurve newViewCurve = vw->GetViewCurve();
double dX = ((1. / zoomFactor) - 1.) *
((newViewCurve.domain[1] - newViewCurve.domain[0]) / 2.);
double dY = ((1. / zoomFactor) - 1.) *
((newViewCurve.range[1] - newViewCurve.range[0]) / 2.);
newViewCurve.domain[0] -= dX;
newViewCurve.domain[1] += dX;
newViewCurve.range[0] -= dY;
newViewCurve.range[1] += dY;
vw->SetViewCurve(newViewCurve);
}
void
VisitHotPointInteractor::Start3DMode(INTERACTION_MODE mode)
{
if(!proxy.HasPlots())
{
return;
}
VisWindow *vw = proxy;
const InteractorAttributes *atts=vw->GetInteractorAtts();
VisitInteractor *newInteractor = NULL;
switch(mode)
{
case LINEOUT: // use Navigate until a 3d lineout mode can be implemented.
case NAVIGATE:
if (atts->GetNavigationMode() == InteractorAttributes::Trackball)
{
if(navigate3D == NULL)
{
navigate3D = new Navigate3D(proxy);
}
newInteractor = navigate3D;
}
else if (atts->GetNavigationMode() == InteractorAttributes::Dolly)
{
if(dolly3D == NULL)
{
dolly3D = new Dolly3D(proxy);
}
newInteractor = dolly3D;
}
else
{
if(flyThrough == NULL)
{
flyThrough = new FlyThrough(proxy);
}
newInteractor = flyThrough;
}
break;
case ZONE_PICK: // fall-through
case NODE_PICK:
case SPREADSHEET_PICK:
case DDT_PICK:
if(pick == NULL)
{
pick = new Pick(proxy);
}
newInteractor = pick;
break;
case ZOOM:
if(zoom3D == NULL)
{
zoom3D = new Zoom3D(proxy);
}
newInteractor = zoom3D;
break;
}
if(newInteractor == NULL)
{
//
// We have an invalid navigation mode or an invalid window mode.
//
EXCEPTION1(BadInteractorException, mode);
}
//
// No reason to set the interactor again if it is the same one.
//
if(newInteractor != currentInteractor)
SetInteractor(newInteractor);
}
void
ZoomCurve::ZoomCamera(void)
{
if (!SufficientDistanceMoved())
{
//
// This is a point, line, or very, very small rectangle.
//
return;
}
//
// Figure out the lower left and upper right hand corners in
// display space.
//
double leftX = (double) (anchorX < lastX ? anchorX : lastX);
double rightX = (double) (anchorX > lastX ? anchorX : lastX);
double bottomY = (double) (anchorY < lastY ? anchorY : lastY);
double topY = (double) (anchorY > lastY ? anchorY : lastY);
double dummyZ = 0.;
//
// Convert them to world coordinates.
//
vtkRenderer *canvas = proxy.GetCanvas();
canvas->DisplayToNormalizedDisplay(leftX, topY);
canvas->NormalizedDisplayToViewport(leftX, topY);
canvas->ViewportToNormalizedViewport(leftX, topY);
canvas->NormalizedViewportToView(leftX, topY, dummyZ);
canvas->ViewToWorld(leftX, topY, dummyZ);
canvas->DisplayToNormalizedDisplay(rightX, bottomY);
canvas->NormalizedDisplayToViewport(rightX, bottomY);
canvas->ViewportToNormalizedViewport(rightX, bottomY);
canvas->NormalizedViewportToView(rightX, bottomY, dummyZ);
canvas->ViewToWorld(rightX, bottomY, dummyZ);
//
// Set the new view window.
//
VisWindow *vw = proxy;
avtViewCurve newViewCurve=vw->GetViewCurve();
int size[2];
vtkRenderWindowInteractor *rwi = Interactor;
rwi->GetSize(size);
double s = newViewCurve.GetScaleFactor(size);
if (!controlKeyDown) // zoom
{
newViewCurve.domain[0] = leftX;
newViewCurve.domain[1] = rightX;
newViewCurve.range[0] = bottomY/s;
newViewCurve.range[1] = topY/s;
}
else // un-zoom
{
float win1[4], win2[4], win3[4], win4[4];
// window created by rubber band
win1[0] = leftX;
win1[1] = rightX;
win1[2] = bottomY;
win1[3] = topY;
float win1_w = win1[1] - win1[0];
float win1_h = win1[3] - win1[2];
// the current window
win2[0] = newViewCurve.domain[0];
win2[1] = newViewCurve.domain[1];
win2[2] = newViewCurve.range[0];
win2[3] = newViewCurve.range[1];
float win2_w = win2[1] - win2[0];
float win2_h = win2[3] - win2[2];
float scaleX = win1_w / win2_w;
float scaleY = win1_h / win2_h;
if (scaleY < scaleX)
{
float midX = (win2[0] + win2[1]) / 2.;
float halfw = (win2_h) * (win1_w / win1_h) / 2.;
win3[0] = midX - halfw;
win3[1] = midX + halfw;
win3[2] = win2[2];
win3[3] = win2[3];
}
else
{
float midY = (win2[2] + win2[3]) /2.;
float halfh = (win2_w) * (win1_h / win1_w) / 2.;
win3[0] = win2[0];
win3[1] = win2[1];
win3[2] = midY - halfh;
win3[3] = midY + halfh;
}
float win3_w = (win3[1] - win3[0]);
float win3_h = (win3[3] - win3[2]);
win4[0] = ((win1[0] - win2[0]) / win2_w) * win3_w + win3[0];
win4[1] = ((win1[1] - win2[0]) / win2_w) * win3_w + win3[0];
win4[2] = ((win1[2] - win2[2]) / win2_h) * win3_h + win3[2];
win4[3] = ((win1[3] - win2[2]) / win2_h) * win3_h + win3[2];
float win4_w = (win4[1] - win4[0]);
float win4_h = (win4[3] - win4[2]);
newViewCurve.domain[0] = (win3[0] - win4[0]) * win3_w / win4_w + win3[0];
newViewCurve.domain[1] = (win3[1] - win4[0]) * win3_w / win4_w + win3[0];
newViewCurve.range[0] = (win3[2] - win4[2]) * win3_h / win4_h + win3[2];
newViewCurve.range[1] = (win3[3] - win4[2]) * win3_h / win4_h + win3[2];
newViewCurve.range[0] /= s;
newViewCurve.range[1] /= s;
}
vw->SetViewCurve(newViewCurve);
//
// It looks like we need to explicitly re-render.
//
proxy.Render();
}
void
Zoom3D::ZoomCamera(void)
{
vtkRenderWindowInteractor *rwi = Interactor;
if (!SufficientDistanceMoved())
{
//
// This is a point, line, or very, very small rectangle
//
return;
}
//
// Determine the size of the window.
//
int size[2];
rwi->GetSize(size);
//
// Get the current view information.
//
VisWindow *vw = proxy;
//
// Set the new image pan and image zoom.
//
double zoomFactor;
double pan[2];
avtView3D newView3D = vw->GetView3D();
if (!controlKeyDown) // zoom
{
pan[0] = (((double)(anchorX + lastX - size[0])) / (2.0 * (double)size[0]))
/ newView3D.imageZoom;
pan[1] = (((double)(anchorY + lastY - size[1])) / (2.0 * (double)size[1]))
/ newView3D.imageZoom;
zoomFactor = fabs((double)(anchorY - lastY)) / (double) size[1];
newView3D.imagePan[0] -= pan[0];
newView3D.imagePan[1] -= pan[1];
newView3D.imageZoom = newView3D.imageZoom / zoomFactor;
}
else // unzoom
{
zoomFactor = fabs((double)(anchorY - lastY)) / (double) size[1];
newView3D.imageZoom = newView3D.imageZoom * zoomFactor;
pan[0] = (((double)(anchorX + lastX - size[0])) / (2.0 * (double)size[0]))
/ newView3D.imageZoom;
pan[1] = (((double)(anchorY + lastY - size[1])) / (2.0 * (double)size[1]))
/ newView3D.imageZoom;
newView3D.imagePan[0] += pan[0];
newView3D.imagePan[1] += pan[1];
}
vw->SetView3D(newView3D);
}
void
NavigateAxisArray::PanCamera(const int x, const int y, bool snap_horiz)
{
vtkRenderWindowInteractor *rwi = Interactor;
if ((OldX != x) || (OldY != y))
{
//
// Determine the size of the window.
//
int size[2];
rwi->GetSize(size);
//
// Get the current view information.
//
VisWindow *vw = proxy;
double pan[2];
avtViewAxisArray newView = vw->GetViewAxisArray();
double xscale = (newView.domain[1] - newView.domain[0]) /
((newView.viewport[1] - newView.viewport[0]) * (double)(size[0]));
double yscale = (newView.range[1] - newView.range[0]) /
((newView.viewport[3] - newView.viewport[2]) * (double)(size[0]));
pan[0] = (double)(x - OldX) * xscale;
pan[1] = (double)(y - OldY) * yscale;
newView.domain[0] -= pan[0];
newView.domain[1] -= pan[0];
newView.range[0] -= pan[1];
newView.range[1] -= pan[1];
// perform a horizontal snap
int newX = x;
if (snap_horiz)
{
double dx0 = newView.domain[0] - double(int(newView.domain[0]));
double dx1 = newView.domain[1] - double(int(newView.domain[1]));
double dx0check = dx0 / (newView.domain[1] - newView.domain[0]);
double dx1check = dx1 / (newView.domain[1] - newView.domain[0]);
const double threshold = 0.025;
if (fabs(dx0check) < threshold)
{
newView.domain[0] -= dx0;
newView.domain[1] -= dx0;
newX += int(.5 + dx0 / xscale);
}
else if (fabs(dx1check) < threshold)
{
newView.domain[0] -= dx1;
newView.domain[1] -= dx1;
newX += int(.5 + dx1 / xscale);
}
}
if (newX == OldX && OldY == y)
{
// do nothing
}
else
{
vw->SetViewAxisArray(newView);
OldX = newX;
OldY = y;
rwi->Render();
}
}
}
avtDataObject_p
IceTNetworkManager::Render(
bool checkThreshold, intVector networkIds,
bool getZBuffer, int annotMode, int windowID,
bool leftEye)
{
int t0 = visitTimer->StartTimer();
DataNetwork *origWorkingNet = workingNet;
avtDataObject_p retval;
EngineVisWinInfo &viswinInfo = viswinMap[windowID];
viswinInfo.markedForDeletion = false;
VisWindow *viswin = viswinInfo.viswin;
std::vector<avtPlot_p>& imageBasedPlots = viswinInfo.imageBasedPlots;
renderings = 0;
TRY
{
this->StartTimer();
RenderSetup(windowID, networkIds, getZBuffer,
annotMode, leftEye, checkThreshold);
bool plotDoingTransparencyOutsideTransparencyActor = false;
for(size_t i = 0 ; i < networkIds.size() ; i++)
{
workingNet = NULL;
UseNetwork(networkIds[i]);
if(this->workingNet->GetPlot()->ManagesOwnTransparency())
{
plotDoingTransparencyOutsideTransparencyActor = true;
}
}
workingNet = NULL;
// We can't easily figure out a compositing order, which IceT requires
// in order to properly composite transparent geometry. Thus if there
// is some transparency, fallback to our parent implementation.
avtTransparencyActor* trans = viswin->GetTransparencyActor();
bool transparenciesExist = trans->TransparenciesExist()
|| plotDoingTransparencyOutsideTransparencyActor;
if (transparenciesExist)
{
debug2 << "Encountered transparency: falling back to old "
"SR / compositing routines." << std::endl;
retval = NetworkManager::RenderInternal();
}
else
{
bool needZB = !imageBasedPlots.empty() ||
renderState.shadowMap ||
renderState.depthCues;
// Confusingly, we need to set the input to be *opposite* of what VisIt
// wants. This is due to (IMHO) poor naming in the IceT case; on the
// input side:
// ICET_DEPTH_BUFFER_BIT set: do Z-testing
// ICET_DEPTH_BUFFER_BIT not set: do Z-based compositing.
// On the output side:
// ICET_DEPTH_BUFFER_BIT set: readback of Z buffer is allowed
// ICET_DEPTH_BUFFER_BIT not set: readback of Z does not work.
// In VisIt's case, we calculated a `need Z buffer' predicate based
// around the idea that we need the Z buffer to do Z-compositing.
// However, IceT \emph{always} needs the Z buffer internally -- the
// flag only differentiates between `compositing' methodologies
// (painter-style or `over' operator) on input.
GLenum inputs = ICET_COLOR_BUFFER_BIT;
GLenum outputs = ICET_COLOR_BUFFER_BIT;
// Scratch all that, I guess. That might be the correct way to go
// about things in the long run, but IceT only gives us back half an
// image if we don't set the depth buffer bit. The compositing is a
// bit wrong, but there's not much else we can do..
// Consider removing the `hack' if a workaround is found.
if (/*hack*/true/*hack*/) // || !this->MemoMultipass(viswin))
{
inputs |= ICET_DEPTH_BUFFER_BIT;
}
if(needZB)
{
outputs |= ICET_DEPTH_BUFFER_BIT;
}
ICET(icetInputOutputBuffers(inputs, outputs));
// If there is a backdrop image, we need to tell IceT so that it can
// composite correctly.
if(viswin->GetBackgroundMode() != AnnotationAttributes::Solid)
{
ICET(icetEnable(ICET_CORRECT_COLORED_BACKGROUND));
}
else
{
ICET(icetDisable(ICET_CORRECT_COLORED_BACKGROUND));
}
if (renderState.renderOnViewer)
{
RenderCleanup();
avtDataObject_p dobj = NULL;
CATCH_RETURN2(1, dobj);
}
debug5 << "Rendering " << viswin->GetNumPrimitives()
<< " primitives." << endl;
int width, height, width_start, height_start;
// This basically gets the width and the height.
// The distinction is for 2D rendering, where we only want the
// width and the height of the viewport.
viswin->GetCaptureRegion(width_start, height_start, width, height,
renderState.viewportedMode);
this->TileLayout(width, height);
CallInitializeProgressCallback(this->RenderingStages());
// IceT mode is different from the standard network manager; we don't
// need to create any compositor or anything: it's all done under the
// hood.
// Whether or not to do multipass rendering (opaque first, translucent
// second) is all handled in the callback; from our perspective, we
// just say draw, read back the image, and post-process it.
// IceT sometimes omits large parts of Curve plots when using the
// REDUCE strategy. Use a different compositing strategy for Curve
// plots to avoid the problem.
if(viswin->GetWindowMode() == WINMODE_CURVE)
ICET(icetStrategy(ICET_STRATEGY_VTREE));
else
ICET(icetStrategy(ICET_STRATEGY_REDUCE));
ICET(icetDrawFunc(render));
ICET(icetDrawFrame());
// Now that we're done rendering, we need to post process the image.
debug3 << "IceTNM: Starting readback." << std::endl;
avtImage_p img = this->Readback(viswin, needZB);
// Now its essentially back to the same behavior as our parent:
// shadows
// depth cueing
// post processing
if (renderState.shadowMap)
this->RenderShadows(img);
if (renderState.depthCues)
this->RenderDepthCues(img);
// If the engine is doing more than just 3D annotations,
// post-process the composited image.
RenderPostProcess(img);
CopyTo(retval, img);
}
RenderCleanup();
}
CATCHALL
{
RenderCleanup();
RETHROW;
}
ENDTRY
workingNet = origWorkingNet;
visitTimer->StopTimer(t0, "Ice-T Render");
return retval;
}
// ****************************************************************************
// Method: VisitHotPointInteractor::StartParallelAxesMode
//
// Purpose:
// Sets up the interactors for ParallelAxes window mode.
//
// Arguments:
// mode the interaction mode
//
// Programmer: Eric Brugger
// Creation: December 9, 2008
//
// Modifications:
// Jonathan Byrd (Allinea Software), Sun Dec 18, 2011
// Added the DDT_PICK mode
//
// Eric Brugger, Mon Nov 5 15:48:46 PST 2012
// I added the ability to display the parallel axes either horizontally
// or vertically.
//
// ****************************************************************************
void
VisitHotPointInteractor::StartParallelAxesMode(INTERACTION_MODE mode)
{
if (!proxy.HasPlots())
{
return;
}
VisWindow *vw = proxy;
VisitInteractor *newInteractor = NULL;
switch(mode)
{
case LINEOUT:
// We don't have a lineout or zoom interaction.
// Fall through to navigation mode.
case NAVIGATE:
if (navigateAxisArray == NULL)
{
navigateAxisArray = new NavigateAxisArray(proxy);
}
if (vw->GetWindowMode() == WINMODE_PARALLELAXES)
{
navigateAxisArray->SetAxisOrientation(NavigateAxisArray::Horizontal);
navigateAxisArray->SetDomainOrientation(NavigateAxisArray::Horizontal);
}
else
{
navigateAxisArray->SetAxisOrientation(NavigateAxisArray::Vertical);
navigateAxisArray->SetDomainOrientation(NavigateAxisArray::Vertical);
}
newInteractor = navigateAxisArray;
break;
case ZOOM:
if(zoomAxisArray == NULL)
{
zoomAxisArray = new ZoomAxisArray(proxy);
}
newInteractor = zoomAxisArray;
break;
case ZONE_PICK:
case NODE_PICK:
case DDT_PICK:
if (pick == NULL)
{
pick = new Pick(proxy);
}
newInteractor = pick;
break;
default:
newInteractor = NULL;
break;
}
if (newInteractor == NULL)
{
//
// We have an invalid navigation mode or an invalid window mode.
//
EXCEPTION1(BadInteractorException, mode);
}
//
// No reason to set the interactor again if it is the same one.
//
if (newInteractor != currentInteractor)
SetInteractor(newInteractor);
}