4 // Core drawing code for Aven.
6 // Copyright (C) 2000-2003,2005,2006 Mark R. Shinwell
7 // Copyright (C) 2001-2003,2004,2005,2006,2007,2010,2011,2012,2014,2015,2016 Olly Betts
8 // Copyright (C) 2005 Martin Green
10 // This program is free software; you can redistribute it and/or modify
11 // it under the terms of the GNU General Public License as published by
12 // the Free Software Foundation; either version 2 of the License, or
13 // (at your option) any later version.
15 // This program is distributed in the hope that it will be useful,
16 // but WITHOUT ANY WARRANTY; without even the implied warranty of
17 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 // GNU General Public License for more details.
20 // You should have received a copy of the GNU General Public License
21 // along with this program; if not, write to the Free Software
22 // Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
40 #include "guicontrol.h"
41 #include "moviemaker.h"
43 #include <wx/confbase.h>
44 #include <wx/wfstream.h>
46 #include <wx/zipstrm.h>
50 const unsigned long DEFAULT_HGT_DIM
= 3601;
51 const unsigned long DEFAULT_HGT_SIZE
= sqrd(DEFAULT_HGT_DIM
) * 2;
53 // Values for m_SwitchingTo
61 // Any error value higher than this is clamped to this.
62 #define MAX_ERROR 12.0
64 // Any length greater than pow(10, LOG_LEN_MAX) will be clamped to this.
65 const Double LOG_LEN_MAX
= 1.5;
67 // How many bins per letter height to use when working out non-overlapping
69 const unsigned int QUANTISE_FACTOR
= 2;
73 static const int INDICATOR_BOX_SIZE
= 60;
74 static const int INDICATOR_GAP
= 2;
75 static const int INDICATOR_MARGIN
= 5;
76 static const int INDICATOR_OFFSET_X
= 15;
77 static const int INDICATOR_OFFSET_Y
= 15;
78 static const int INDICATOR_RADIUS
= INDICATOR_BOX_SIZE
/ 2 - INDICATOR_MARGIN
;
79 static const int KEY_OFFSET_X
= 10;
80 static const int KEY_OFFSET_Y
= 10;
81 static const int KEY_EXTRA_LEFT_MARGIN
= 2;
82 static const int KEY_BLOCK_WIDTH
= 20;
83 static const int KEY_BLOCK_HEIGHT
= 16;
84 static const int TICK_LENGTH
= 4;
85 static const int SCALE_BAR_OFFSET_X
= 15;
86 static const int SCALE_BAR_OFFSET_Y
= 12;
87 static const int SCALE_BAR_HEIGHT
= 12;
89 static const gla_colour TEXT_COLOUR
= col_GREEN
;
90 static const gla_colour HERE_COLOUR
= col_WHITE
;
91 static const gla_colour NAME_COLOUR
= col_GREEN
;
92 static const gla_colour SEL_COLOUR
= col_WHITE
;
94 // Number of entries across and down the hit-test grid:
95 #define HITTEST_SIZE 20
97 // How close the pointer needs to be to a station to be considered:
98 #define MEASURE_THRESHOLD 7
100 // vector for lighting angle
101 static const Vector3
light(.577, .577, .577);
103 BEGIN_EVENT_TABLE(GfxCore
, GLACanvas
)
104 EVT_PAINT(GfxCore::OnPaint
)
105 EVT_LEFT_DOWN(GfxCore::OnLButtonDown
)
106 EVT_LEFT_UP(GfxCore::OnLButtonUp
)
107 EVT_MIDDLE_DOWN(GfxCore::OnMButtonDown
)
108 EVT_MIDDLE_UP(GfxCore::OnMButtonUp
)
109 EVT_RIGHT_DOWN(GfxCore::OnRButtonDown
)
110 EVT_RIGHT_UP(GfxCore::OnRButtonUp
)
111 EVT_MOUSEWHEEL(GfxCore::OnMouseWheel
)
112 EVT_MOTION(GfxCore::OnMouseMove
)
113 EVT_LEAVE_WINDOW(GfxCore::OnLeaveWindow
)
114 EVT_SIZE(GfxCore::OnSize
)
115 EVT_IDLE(GfxCore::OnIdle
)
116 EVT_CHAR(GfxCore::OnKeyPress
)
119 GfxCore::GfxCore(MainFrm
* parent
, wxWindow
* parent_win
, GUIControl
* control
) :
120 GLACanvas(parent_win
, 100),
127 m_DoneFirstShow(false),
135 m_Splays(SPLAYS_SHOW_FADED
),
139 m_OverlappingNames(false),
143 m_ColourBy(COLOUR_BY_DEPTH
),
146 m_MouseOutsideCompass(false),
147 m_MouseOutsideElev(false),
151 m_ExportedPts(false),
153 m_BoundingBox(false),
158 m_HitTestDebug(false),
159 m_RenderStats(false),
161 m_HitTestGridValid(false),
164 presentation_mode(0),
168 current_cursor(GfxCore::CURSOR_DEFAULT
),
169 sqrd_measure_threshold(sqrd(MEASURE_THRESHOLD
)),
174 AddQuad
= &GfxCore::AddQuadrilateralDepth
;
175 AddPoly
= &GfxCore::AddPolylineDepth
;
176 wxConfigBase::Get()->Read(wxT("metric"), &m_Metric
, true);
177 wxConfigBase::Get()->Read(wxT("degrees"), &m_Degrees
, true);
178 wxConfigBase::Get()->Read(wxT("percent"), &m_Percent
, false);
180 for (int pen
= 0; pen
< NUM_COLOUR_BANDS
+ 1; ++pen
) {
181 m_Pens
[pen
].SetColour(REDS
[pen
] / 255.0,
193 delete[] m_PointGrid
;
196 void GfxCore::TryToFreeArrays()
198 // Free up any memory allocated for arrays.
199 delete[] m_LabelGrid
;
204 // Initialisation methods
207 void GfxCore::Initialise(bool same_file
)
209 // Initialise the view from the parent holding the survey data.
213 m_DoneFirstShow
= false;
215 m_HitTestGridValid
= false;
219 m_MouseOutsideCompass
= m_MouseOutsideElev
= false;
222 // Apply default parameters unless reloading the same file.
228 // Clear any cached OpenGL lists which depend on the data.
229 InvalidateList(LIST_SCALE_BAR
);
230 InvalidateList(LIST_DEPTH_KEY
);
231 InvalidateList(LIST_DATE_KEY
);
232 InvalidateList(LIST_ERROR_KEY
);
233 InvalidateList(LIST_GRADIENT_KEY
);
234 InvalidateList(LIST_LENGTH_KEY
);
235 InvalidateList(LIST_UNDERGROUND_LEGS
);
236 InvalidateList(LIST_TUBES
);
237 InvalidateList(LIST_SURFACE_LEGS
);
238 InvalidateList(LIST_BLOBS
);
239 InvalidateList(LIST_CROSSES
);
240 InvalidateList(LIST_GRID
);
241 InvalidateList(LIST_SHADOW
);
242 InvalidateList(LIST_TERRAIN
);
244 // Set diameter of the viewing volume.
245 double cave_diameter
= sqrt(sqrd(m_Parent
->GetXExtent()) +
246 sqrd(m_Parent
->GetYExtent()) +
247 sqrd(m_Parent
->GetZExtent()));
249 // Allow for terrain.
250 double diameter
= max(1000.0 * 2, cave_diameter
* 2);
253 SetVolumeDiameter(diameter
);
255 // Set initial scale based on the size of the cave.
256 initial_scale
= diameter
/ cave_diameter
;
257 SetScale(initial_scale
);
259 // Adjust the position when restricting the view to a subsurvey (or
260 // expanding the view to show the whole survey).
261 AddTranslation(m_Parent
->GetOffset() - offsets
);
263 // Try to keep the same scale, allowing for the
264 // cave having grown (or shrunk).
265 double rescale
= GetVolumeDiameter() / diameter
;
266 SetVolumeDiameter(diameter
);
267 SetScale(GetScale() / rescale
); // ?
268 initial_scale
= initial_scale
* rescale
;
271 offsets
= m_Parent
->GetOffset();
276 void GfxCore::FirstShow()
278 GLACanvas::FirstShow();
280 const unsigned int quantise(GetFontSize() / QUANTISE_FACTOR
);
281 list
<LabelInfo
*>::iterator pos
= m_Parent
->GetLabelsNC();
282 while (pos
!= m_Parent
->GetLabelsNCEnd()) {
283 LabelInfo
* label
= *pos
++;
284 // Calculate and set the label width for use when plotting
285 // none-overlapping labels.
287 GLACanvas::GetTextExtent(label
->GetText(), &ext_x
, NULL
);
288 label
->set_width(unsigned(ext_x
) / quantise
+ 1);
291 m_DoneFirstShow
= true;
295 // Recalculating methods
298 void GfxCore::SetScale(Double scale
)
302 } else if (scale
> GetVolumeDiameter()) {
303 scale
= GetVolumeDiameter();
307 m_HitTestGridValid
= false;
308 if (m_here
&& m_here
== &temp_here
) SetHere();
310 GLACanvas::SetScale(scale
);
313 bool GfxCore::HasUndergroundLegs() const
315 return m_Parent
->HasUndergroundLegs();
318 bool GfxCore::HasSplays() const
320 return m_Parent
->HasSplays();
323 bool GfxCore::HasSurfaceLegs() const
325 return m_Parent
->HasSurfaceLegs();
328 bool GfxCore::HasTubes() const
330 return m_Parent
->HasTubes();
333 void GfxCore::UpdateBlobs()
335 InvalidateList(LIST_BLOBS
);
342 void GfxCore::OnLeaveWindow(wxMouseEvent
&) {
347 void GfxCore::OnIdle(wxIdleEvent
& event
)
349 // Handle an idle event.
352 // If still animating, we want more idle events.
356 // If we're idle, don't show a bogus FPS next time we render.
361 void GfxCore::OnPaint(wxPaintEvent
&)
363 // Redraw the window.
365 // Get a graphics context.
369 // Make sure we're initialised.
370 bool first_time
= !m_DoneFirstShow
;
377 // Clear the background.
380 // Set up model transformation matrix.
383 if (m_Legs
|| m_Tubes
) {
385 EnableSmoothPolygons(true); // FIXME: allow false for wireframe view
386 DrawList(LIST_TUBES
);
387 DisableSmoothPolygons();
390 // Draw the underground legs. Do this last so that anti-aliasing
391 // works over polygons.
392 SetColour(col_GREEN
);
393 DrawList(LIST_UNDERGROUND_LEGS
);
397 // Draw the surface legs.
398 DrawList(LIST_SURFACE_LEGS
);
402 DrawShadowedBoundingBox();
409 DrawList(LIST_BLOBS
);
412 DrawList(LIST_CROSSES
);
416 // This is needed if blobs and/or crosses are drawn using lines -
417 // otherwise the terrain doesn't appear when they are enabled.
420 // We don't want to be able to see the terrain through itself, so
421 // do a "Z-prepass" - plot the terrain once only updating the
422 // Z-buffer, then again with Z-clipping only plotting where the
423 // depth matches the value in the Z-buffer.
424 DrawListZPrepass(LIST_TERRAIN
);
427 SetIndicatorTransform();
429 // Draw station names.
430 if (m_Names
/*&& !m_Control->MouseDown() && !Animating()*/) {
431 SetColour(NAME_COLOUR
);
433 if (m_OverlappingNames
) {
440 if (m_HitTestDebug
) {
441 // Show the hit test grid bucket sizes...
442 SetColour(m_HitTestGridValid
? col_LIGHT_GREY
: col_DARK_GREY
);
444 for (int i
= 0; i
!= HITTEST_SIZE
; ++i
) {
445 int x
= (GetXSize() + 1) * i
/ HITTEST_SIZE
+ 2;
446 for (int j
= 0; j
!= HITTEST_SIZE
; ++j
) {
447 int square
= i
+ j
* HITTEST_SIZE
;
448 unsigned long bucket_size
= m_PointGrid
[square
].size();
450 int y
= (GetYSize() + 1) * (HITTEST_SIZE
- 1 - j
) / HITTEST_SIZE
;
451 DrawIndicatorText(x
, y
, wxString::Format(wxT("%lu"), bucket_size
));
459 for (int i
= 0; i
!= HITTEST_SIZE
; ++i
) {
460 int x
= (GetXSize() + 1) * i
/ HITTEST_SIZE
;
461 PlaceIndicatorVertex(x
, 0);
462 PlaceIndicatorVertex(x
, GetYSize());
464 for (int j
= 0; j
!= HITTEST_SIZE
; ++j
) {
465 int y
= (GetYSize() + 1) * (HITTEST_SIZE
- 1 - j
) / HITTEST_SIZE
;
466 PlaceIndicatorVertex(0, y
);
467 PlaceIndicatorVertex(GetXSize(), y
);
470 DisableDashedLines();
473 long now
= timer
.Time();
475 // Show stats about rendering.
476 SetColour(col_TURQUOISE
);
477 int y
= GetYSize() - GetFontSize();
478 if (last_time
!= 0.0) {
479 // timer.Time() measure in milliseconds.
480 double fps
= 1000.0 / (now
- last_time
);
481 DrawIndicatorText(1, y
, wxString::Format(wxT("FPS:% 5.1f"), fps
));
484 DrawIndicatorText(1, y
, wxString::Format(wxT("▲:%lu"), (unsigned long)n_tris
));
490 // There's no advantage in generating an OpenGL list for the
491 // indicators since they change with almost every redraw (and
492 // sometimes several times between redraws). This way we avoid
493 // the need to track when to update the indicator OpenGL list,
494 // and also avoid indicator update bugs when we don't quite get this
498 if (zoombox
.active()) {
499 SetColour(SEL_COLOUR
);
502 glaCoord Y
= GetYSize();
503 PlaceIndicatorVertex(zoombox
.x1
, Y
- zoombox
.y1
);
504 PlaceIndicatorVertex(zoombox
.x1
, Y
- zoombox
.y2
);
505 PlaceIndicatorVertex(zoombox
.x2
, Y
- zoombox
.y2
);
506 PlaceIndicatorVertex(zoombox
.x2
, Y
- zoombox
.y1
);
507 PlaceIndicatorVertex(zoombox
.x1
, Y
- zoombox
.y1
);
509 DisableDashedLines();
510 } else if (MeasuringLineActive()) {
511 // Draw "here" and "there".
513 SetColour(HERE_COLOUR
);
516 Transform(*m_here
, &hx
, &hy
, &dummy
);
517 if (m_here
!= &temp_here
) DrawRing(hx
, hy
);
522 Transform(*m_there
, &tx
, &ty
, &dummy
);
525 PlaceIndicatorVertex(hx
, hy
);
526 PlaceIndicatorVertex(tx
, ty
);
537 dc
.SetBackground(wxSystemSettings::GetColour(wxSYS_COLOUR_WINDOWFRAME
));
542 void GfxCore::DrawBoundingBox()
544 const Vector3 v
= 0.5 * m_Parent
->GetExtent();
549 PlaceVertex(-v
.GetX(), -v
.GetY(), v
.GetZ());
550 PlaceVertex(-v
.GetX(), v
.GetY(), v
.GetZ());
551 PlaceVertex(v
.GetX(), v
.GetY(), v
.GetZ());
552 PlaceVertex(v
.GetX(), -v
.GetY(), v
.GetZ());
553 PlaceVertex(-v
.GetX(), -v
.GetY(), v
.GetZ());
556 PlaceVertex(-v
.GetX(), -v
.GetY(), -v
.GetZ());
557 PlaceVertex(-v
.GetX(), v
.GetY(), -v
.GetZ());
558 PlaceVertex(v
.GetX(), v
.GetY(), -v
.GetZ());
559 PlaceVertex(v
.GetX(), -v
.GetY(), -v
.GetZ());
560 PlaceVertex(-v
.GetX(), -v
.GetY(), -v
.GetZ());
563 PlaceVertex(-v
.GetX(), -v
.GetY(), v
.GetZ());
564 PlaceVertex(-v
.GetX(), -v
.GetY(), -v
.GetZ());
565 PlaceVertex(-v
.GetX(), v
.GetY(), v
.GetZ());
566 PlaceVertex(-v
.GetX(), v
.GetY(), -v
.GetZ());
567 PlaceVertex(v
.GetX(), v
.GetY(), v
.GetZ());
568 PlaceVertex(v
.GetX(), v
.GetY(), -v
.GetZ());
569 PlaceVertex(v
.GetX(), -v
.GetY(), v
.GetZ());
570 PlaceVertex(v
.GetX(), -v
.GetY(), -v
.GetZ());
572 DisableDashedLines();
575 void GfxCore::DrawShadowedBoundingBox()
577 const Vector3 v
= 0.5 * m_Parent
->GetExtent();
582 SetColour(col_DARK_GREY
);
583 BeginQuadrilaterals();
584 PlaceVertex(-v
.GetX(), -v
.GetY(), -v
.GetZ());
585 PlaceVertex(-v
.GetX(), v
.GetY(), -v
.GetZ());
586 PlaceVertex(v
.GetX(), v
.GetY(), -v
.GetZ());
587 PlaceVertex(v
.GetX(), -v
.GetY(), -v
.GetZ());
589 PolygonOffset(false);
591 DrawList(LIST_SHADOW
);
594 void GfxCore::DrawGrid()
599 // Calculate the extent of the survey, in metres across the screen plane.
600 Double m_across_screen
= SurveyUnitsAcrossViewport();
601 // Calculate the length of the scale bar in metres.
602 //--move this elsewhere
603 Double size_snap
= pow(10.0, floor(log10(0.75 * m_across_screen
)));
604 Double t
= m_across_screen
* 0.75 / size_snap
;
612 Double grid_size
= size_snap
* 0.1;
613 Double edge
= grid_size
* 2.0;
614 Double grid_z
= -m_Parent
->GetZExtent() * 0.5 - grid_size
;
615 Double left
= -m_Parent
->GetXExtent() * 0.5 - edge
;
616 Double right
= m_Parent
->GetXExtent() * 0.5 + edge
;
617 Double bottom
= -m_Parent
->GetYExtent() * 0.5 - edge
;
618 Double top
= m_Parent
->GetYExtent() * 0.5 + edge
;
619 int count_x
= (int) ceil((right
- left
) / grid_size
);
620 int count_y
= (int) ceil((top
- bottom
) / grid_size
);
621 Double actual_right
= left
+ count_x
*grid_size
;
622 Double actual_top
= bottom
+ count_y
*grid_size
;
626 for (int xc
= 0; xc
<= count_x
; xc
++) {
627 Double x
= left
+ xc
*grid_size
;
629 PlaceVertex(x
, bottom
, grid_z
);
630 PlaceVertex(x
, actual_top
, grid_z
);
633 for (int yc
= 0; yc
<= count_y
; yc
++) {
634 Double y
= bottom
+ yc
*grid_size
;
635 PlaceVertex(left
, y
, grid_z
);
636 PlaceVertex(actual_right
, y
, grid_z
);
642 int GfxCore::GetClinoOffset() const
644 int result
= INDICATOR_OFFSET_X
;
646 result
+= 6 + GetCompassWidth() + INDICATOR_GAP
;
651 void GfxCore::DrawTick(int angle_cw
)
653 const Double theta
= rad(angle_cw
);
654 const wxCoord length1
= INDICATOR_RADIUS
;
655 const wxCoord length0
= length1
+ TICK_LENGTH
;
656 wxCoord x0
= wxCoord(length0
* sin(theta
));
657 wxCoord y0
= wxCoord(length0
* cos(theta
));
658 wxCoord x1
= wxCoord(length1
* sin(theta
));
659 wxCoord y1
= wxCoord(length1
* cos(theta
));
661 PlaceIndicatorVertex(x0
, y0
);
662 PlaceIndicatorVertex(x1
, y1
);
665 void GfxCore::DrawArrow(gla_colour col1
, gla_colour col2
) {
666 Vector3
p1(0, INDICATOR_RADIUS
, 0);
667 Vector3
p2(INDICATOR_RADIUS
/2, INDICATOR_RADIUS
*-.866025404, 0); // 150deg
668 Vector3
p3(-INDICATOR_RADIUS
/2, INDICATOR_RADIUS
*-.866025404, 0); // 210deg
671 DrawTriangle(col_LIGHT_GREY
, col1
, p2
, p1
, pc
);
672 DrawTriangle(col_LIGHT_GREY
, col2
, p3
, p1
, pc
);
675 void GfxCore::DrawCompass() {
678 for (int angle
= 315; angle
> 0; angle
-= 45) {
681 SetColour(col_GREEN
);
685 // Compass background.
686 DrawCircle(col_LIGHT_GREY_2
, col_GREY
, 0, 0, INDICATOR_RADIUS
);
689 DrawArrow(col_INDICATOR_1
, col_INDICATOR_2
);
692 // Draw the non-rotating background to the clino.
693 void GfxCore::DrawClinoBack() {
695 for (int angle
= 0; angle
<= 180; angle
+= 90) {
700 PlaceIndicatorVertex(0, INDICATOR_RADIUS
);
701 PlaceIndicatorVertex(0, -INDICATOR_RADIUS
);
702 PlaceIndicatorVertex(0, 0);
703 PlaceIndicatorVertex(INDICATOR_RADIUS
, 0);
708 void GfxCore::DrawClino() {
710 SetColour(col_GREEN
);
716 DrawSemicircle(col_LIGHT_GREY_2
, col_GREY
, 0, 0, INDICATOR_RADIUS
, 0);
719 DrawArrow(col_INDICATOR_2
, col_INDICATOR_1
);
722 void GfxCore::Draw2dIndicators()
724 // Draw the compass and elevation indicators.
726 const int centre_y
= INDICATOR_BOX_SIZE
/ 2 + INDICATOR_OFFSET_Y
;
728 const int comp_centre_x
= GetCompassXPosition();
730 if (m_Compass
&& !m_Parent
->IsExtendedElevation()) {
731 // If the user is dragging the compass with the pointer outside the
732 // compass, we snap to 45 degree multiples, and the ticks go white.
733 SetColour(m_MouseOutsideCompass
? col_WHITE
: col_LIGHT_GREY_2
);
734 DrawList2D(LIST_COMPASS
, comp_centre_x
, centre_y
, -m_PanAngle
);
737 const int elev_centre_x
= GetClinoXPosition();
740 // If the user is dragging the clino with the pointer outside the
741 // clino, we snap to 90 degree multiples, and the ticks go white.
742 SetColour(m_MouseOutsideElev
? col_WHITE
: col_LIGHT_GREY_2
);
743 DrawList2D(LIST_CLINO_BACK
, elev_centre_x
, centre_y
, 0);
744 DrawList2D(LIST_CLINO
, elev_centre_x
, centre_y
, 90 - m_TiltAngle
);
747 SetColour(TEXT_COLOUR
);
749 static int triple_zero_width
= 0;
750 static int height
= 0;
751 if (!triple_zero_width
) {
752 GetTextExtent(wxT("000"), &triple_zero_width
, &height
);
754 const int y_off
= INDICATOR_OFFSET_Y
+ INDICATOR_BOX_SIZE
+ height
/ 2;
756 if (m_Compass
&& !m_Parent
->IsExtendedElevation()) {
761 value
= int(m_PanAngle
);
762 /* TRANSLATORS: degree symbol - probably should be translated to
766 value
= int(m_PanAngle
* 200.0 / 180.0);
767 /* TRANSLATORS: symbol for grad (400 grad = 360 degrees = full
771 str
.Printf(wxT("%03d"), value
);
772 str
+= wmsg(brg_unit
);
773 DrawIndicatorText(comp_centre_x
- triple_zero_width
/ 2, y_off
, str
);
775 // TRANSLATORS: Used in aven above the compass indicator at the lower
776 // right of the display, with a bearing below "Facing". This indicates the
777 // direction the viewer is "facing" in.
779 // Try to keep this translation short - ideally at most 10 characters -
780 // as otherwise the compass and clino will be moved further apart to
782 str
= wmsg(/*Facing*/203);
784 GetTextExtent(str
, &w
, NULL
);
785 DrawIndicatorText(comp_centre_x
- w
/ 2, y_off
+ height
, str
);
789 if (m_TiltAngle
== -90.0) {
790 // TRANSLATORS: Label used for "clino" in Aven when the view is
791 // from directly above.
793 // Try to keep this translation short - ideally at most 10
794 // characters - as otherwise the compass and clino will be moved
795 // further apart to make room. */
796 wxString str
= wmsg(/*Plan*/432);
797 static int width
= 0;
799 GetTextExtent(str
, &width
, NULL
);
801 int x
= elev_centre_x
- width
/ 2;
802 DrawIndicatorText(x
, y_off
+ height
/ 2, str
);
803 } else if (m_TiltAngle
== 90.0) {
804 // TRANSLATORS: Label used for "clino" in Aven when the view is
805 // from directly below.
807 // Try to keep this translation short - ideally at most 10
808 // characters - as otherwise the compass and clino will be moved
809 // further apart to make room. */
810 wxString str
= wmsg(/*Kiwi Plan*/433);
811 static int width
= 0;
813 GetTextExtent(str
, &width
, NULL
);
815 int x
= elev_centre_x
- width
/ 2;
816 DrawIndicatorText(x
, y_off
+ height
/ 2, str
);
823 static int zero_width
= 0;
825 GetTextExtent(wxT("0"), &zero_width
, NULL
);
828 if (m_TiltAngle
> 89.99) {
830 } else if (m_TiltAngle
< -89.99) {
833 angle
= int(100 * tan(rad(m_TiltAngle
)));
835 if (angle
> 99999 || angle
< -99999) {
836 str
= angle
> 0 ? wxT("+") : wxT("-");
837 /* TRANSLATORS: infinity symbol - used for the percentage gradient on
838 * vertical angles. */
839 str
+= wmsg(/*∞*/431);
841 str
= angle
? wxString::Format(wxT("%+03d"), angle
) : wxT("0");
843 /* TRANSLATORS: symbol for percentage gradient (100% = 45
844 * degrees = 50 grad). */
846 } else if (m_Degrees
) {
847 static int zero_zero_width
= 0;
848 if (!zero_zero_width
) {
849 GetTextExtent(wxT("00"), &zero_zero_width
, NULL
);
851 width
= zero_zero_width
;
852 angle
= int(m_TiltAngle
);
853 str
= angle
? wxString::Format(wxT("%+03d"), angle
) : wxT("00");
856 width
= triple_zero_width
;
857 angle
= int(m_TiltAngle
* 200.0 / 180.0);
858 str
= angle
? wxString::Format(wxT("%+04d"), angle
) : wxT("000");
863 if (unit
== /*%*/96) {
864 // Right align % since the width changes so much.
865 GetTextExtent(str
, &sign_offset
, NULL
);
866 sign_offset
-= width
;
867 } else if (angle
< 0) {
868 // Adjust horizontal position so the left of the first digit is
869 // always in the same place.
870 static int minus_width
= 0;
872 GetTextExtent(wxT("-"), &minus_width
, NULL
);
874 sign_offset
= minus_width
;
875 } else if (angle
> 0) {
876 // Adjust horizontal position so the left of the first digit is
877 // always in the same place.
878 static int plus_width
= 0;
880 GetTextExtent(wxT("+"), &plus_width
, NULL
);
882 sign_offset
= plus_width
;
886 DrawIndicatorText(elev_centre_x
- sign_offset
- width
/ 2, y_off
, str
);
888 // TRANSLATORS: Label used for "clino" in Aven when the view is
889 // neither from directly above nor from directly below. It is
890 // also used in the dialog for editing a marked position in a
893 // Try to keep this translation short - ideally at most 10
894 // characters - as otherwise the compass and clino will be moved
895 // further apart to make room. */
896 str
= wmsg(/*Elevation*/118);
897 static int elevation_width
= 0;
898 if (!elevation_width
) {
899 GetTextExtent(str
, &elevation_width
, NULL
);
901 int x
= elev_centre_x
- elevation_width
/ 2;
902 DrawIndicatorText(x
, y_off
+ height
, str
);
907 void GfxCore::NattyDrawNames()
909 // Draw station names, without overlapping.
911 const unsigned int quantise(GetFontSize() / QUANTISE_FACTOR
);
912 const unsigned int quantised_x
= GetXSize() / quantise
;
913 const unsigned int quantised_y
= GetYSize() / quantise
;
914 const size_t buffer_size
= quantised_x
* quantised_y
;
916 if (!m_LabelGrid
) m_LabelGrid
= new char[buffer_size
];
918 memset((void*) m_LabelGrid
, 0, buffer_size
);
920 list
<LabelInfo
*>::const_iterator label
= m_Parent
->GetLabels();
921 for ( ; label
!= m_Parent
->GetLabelsEnd(); ++label
) {
922 if (!((m_Surface
&& (*label
)->IsSurface()) ||
923 (m_Legs
&& (*label
)->IsUnderground()) ||
924 (!(*label
)->IsSurface() && !(*label
)->IsUnderground()))) {
925 // if this station isn't to be displayed, skip to the next
926 // (last case is for stns with no legs attached)
932 Transform(**label
, &x
, &y
, &z
);
933 // Check if the label is behind us (in perspective view).
934 if (z
<= 0.0 || z
>= 1.0) continue;
936 // Apply a small shift so that translating the view doesn't make which
937 // labels are displayed change as the resulting twinkling effect is
940 Transform(Vector3(), &tx
, &ty
, &tz
);
941 tx
-= floor(tx
/ quantise
) * quantise
;
942 ty
-= floor(ty
/ quantise
) * quantise
;
945 if (tx
< 0) continue;
948 if (ty
< 0) continue;
950 unsigned int iy
= unsigned(ty
) / quantise
;
951 if (iy
>= quantised_y
) continue;
952 unsigned int width
= (*label
)->get_width();
953 unsigned int ix
= unsigned(tx
) / quantise
;
954 if (ix
+ width
>= quantised_x
) continue;
956 char * test
= m_LabelGrid
+ ix
+ iy
* quantised_x
;
957 if (memchr(test
, 1, width
)) continue;
960 y
-= GetFontSize() / 2;
961 DrawIndicatorText((int)x
, (int)y
, (*label
)->GetText());
963 if (iy
> QUANTISE_FACTOR
) iy
= QUANTISE_FACTOR
;
964 test
-= quantised_x
* iy
;
966 while (--iy
&& test
< m_LabelGrid
+ buffer_size
) {
967 memset(test
, 1, width
);
973 void GfxCore::SimpleDrawNames()
975 // Draw all station names, without worrying about overlaps
976 list
<LabelInfo
*>::const_iterator label
= m_Parent
->GetLabels();
977 for ( ; label
!= m_Parent
->GetLabelsEnd(); ++label
) {
978 if (!((m_Surface
&& (*label
)->IsSurface()) ||
979 (m_Legs
&& (*label
)->IsUnderground()) ||
980 (!(*label
)->IsSurface() && !(*label
)->IsUnderground()))) {
981 // if this station isn't to be displayed, skip to the next
982 // (last case is for stns with no legs attached)
987 Transform(**label
, &x
, &y
, &z
);
989 // Check if the label is behind us (in perspective view).
990 if (z
<= 0) continue;
993 y
-= GetFontSize() / 2;
994 DrawIndicatorText((int)x
, (int)y
, (*label
)->GetText());
998 void GfxCore::DrawColourKey(int num_bands
, const wxString
& other
, const wxString
& units
)
1000 int total_block_height
=
1001 KEY_BLOCK_HEIGHT
* (num_bands
== 1 ? num_bands
: num_bands
- 1);
1002 if (!other
.empty()) total_block_height
+= KEY_BLOCK_HEIGHT
* 2;
1003 if (!units
.empty()) total_block_height
+= KEY_BLOCK_HEIGHT
;
1005 const int bottom
= -total_block_height
;
1008 if (!other
.empty()) GetTextExtent(other
, &size
, NULL
);
1010 for (band
= 0; band
< num_bands
; ++band
) {
1012 GetTextExtent(key_legends
[band
], &x
, NULL
);
1013 if (x
> size
) size
= x
;
1016 int left
= -KEY_BLOCK_WIDTH
- size
;
1018 key_lowerleft
[m_ColourBy
].x
= left
- KEY_EXTRA_LEFT_MARGIN
;
1019 key_lowerleft
[m_ColourBy
].y
= bottom
;
1022 if (!units
.empty()) y
+= KEY_BLOCK_HEIGHT
;
1024 if (!other
.empty()) {
1025 DrawShadedRectangle(GetSurfacePen(), GetSurfacePen(), left
, y
,
1026 KEY_BLOCK_WIDTH
, KEY_BLOCK_HEIGHT
);
1027 SetColour(col_BLACK
);
1029 PlaceIndicatorVertex(left
, y
);
1030 PlaceIndicatorVertex(left
+ KEY_BLOCK_WIDTH
, y
);
1031 PlaceIndicatorVertex(left
+ KEY_BLOCK_WIDTH
, y
+ KEY_BLOCK_HEIGHT
);
1032 PlaceIndicatorVertex(left
, y
+ KEY_BLOCK_HEIGHT
);
1033 PlaceIndicatorVertex(left
, y
);
1035 y
+= KEY_BLOCK_HEIGHT
* 2;
1039 if (num_bands
== 1) {
1040 DrawShadedRectangle(GetPen(0), GetPen(0), left
, y
,
1041 KEY_BLOCK_WIDTH
, KEY_BLOCK_HEIGHT
);
1042 y
+= KEY_BLOCK_HEIGHT
;
1044 for (band
= 0; band
< num_bands
- 1; ++band
) {
1045 DrawShadedRectangle(GetPen(band
), GetPen(band
+ 1), left
, y
,
1046 KEY_BLOCK_WIDTH
, KEY_BLOCK_HEIGHT
);
1047 y
+= KEY_BLOCK_HEIGHT
;
1051 SetColour(col_BLACK
);
1053 PlaceIndicatorVertex(left
, y
);
1054 PlaceIndicatorVertex(left
+ KEY_BLOCK_WIDTH
, y
);
1055 PlaceIndicatorVertex(left
+ KEY_BLOCK_WIDTH
, start
);
1056 PlaceIndicatorVertex(left
, start
);
1057 PlaceIndicatorVertex(left
, y
);
1060 SetColour(TEXT_COLOUR
);
1063 if (!units
.empty()) {
1064 GetTextExtent(units
, &size
, NULL
);
1065 DrawIndicatorText(left
+ (KEY_BLOCK_WIDTH
- size
) / 2, y
, units
);
1066 y
+= KEY_BLOCK_HEIGHT
;
1068 y
-= GetFontSize() / 2;
1069 left
+= KEY_BLOCK_WIDTH
+ 5;
1071 if (!other
.empty()) {
1072 y
+= KEY_BLOCK_HEIGHT
/ 2;
1073 DrawIndicatorText(left
, y
, other
);
1074 y
+= KEY_BLOCK_HEIGHT
* 2 - KEY_BLOCK_HEIGHT
/ 2;
1077 if (num_bands
== 1) {
1078 y
+= KEY_BLOCK_HEIGHT
/ 2;
1079 DrawIndicatorText(left
, y
, key_legends
[0]);
1081 for (band
= 0; band
< num_bands
; ++band
) {
1082 DrawIndicatorText(left
, y
, key_legends
[band
]);
1083 y
+= KEY_BLOCK_HEIGHT
;
1088 void GfxCore::DrawDepthKey()
1090 Double z_ext
= m_Parent
->GetDepthExtent();
1094 num_bands
= GetNumColourBands();
1095 Double z_range
= z_ext
;
1096 if (!m_Metric
) z_range
/= METRES_PER_FOOT
;
1097 sf
= max(0, 1 - (int)floor(log10(z_range
)));
1100 Double z_min
= m_Parent
->GetDepthMin() + m_Parent
->GetOffset().GetZ();
1101 for (int band
= 0; band
< num_bands
; ++band
) {
1104 z
+= z_ext
* band
/ (num_bands
- 1);
1107 z
/= METRES_PER_FOOT
;
1109 key_legends
[band
].Printf(wxT("%.*f"), sf
, z
);
1112 DrawColourKey(num_bands
, wxString(), wmsg(m_Metric
? /*m*/424: /*ft*/428));
1115 void GfxCore::DrawDateKey()
1118 if (!HasDateInformation()) {
1121 int date_ext
= m_Parent
->GetDateExtent();
1122 if (date_ext
== 0) {
1125 num_bands
= GetNumColourBands();
1127 for (int band
= 0; band
< num_bands
; ++band
) {
1129 int days
= m_Parent
->GetDateMin();
1131 days
+= date_ext
* band
/ (num_bands
- 1);
1132 ymd_from_days_since_1900(days
, &y
, &m
, &d
);
1133 key_legends
[band
].Printf(wxT("%04d-%02d-%02d"), y
, m
, d
);
1138 if (!m_Parent
->HasCompleteDateInfo()) {
1139 /* TRANSLATORS: Used in the "colour key" for "colour by date" if there
1140 * are surveys without date information. Try to keep this fairly short.
1142 other
= wmsg(/*Undated*/221);
1145 DrawColourKey(num_bands
, other
, wxString());
1148 void GfxCore::DrawErrorKey()
1151 if (HasErrorInformation()) {
1152 // Use fixed colours for each error factor so it's directly visually
1153 // comparable between surveys.
1154 num_bands
= GetNumColourBands();
1155 for (int band
= 0; band
< num_bands
; ++band
) {
1156 double E
= MAX_ERROR
* band
/ (num_bands
- 1);
1157 key_legends
[band
].Printf(wxT("%.2f"), E
);
1163 // Always show the "Not in loop" legend for now (FIXME).
1164 /* TRANSLATORS: Used in the "colour key" for "colour by error" for surveys
1165 * which aren’t part of a loop and so have no error information. Try to keep
1166 * this fairly short. */
1167 DrawColourKey(num_bands
, wmsg(/*Not in loop*/290), wxString());
1170 void GfxCore::DrawGradientKey()
1173 // Use fixed colours for each gradient so it's directly visually comparable
1175 num_bands
= GetNumColourBands();
1176 wxString units
= wmsg(m_Degrees
? /*°*/344 : /*ᵍ*/76);
1177 for (int band
= 0; band
< num_bands
; ++band
) {
1178 double gradient
= double(band
) / (num_bands
- 1);
1184 key_legends
[band
].Printf(wxT("%.f%s"), gradient
, units
);
1187 DrawColourKey(num_bands
, wxString(), wxString());
1190 void GfxCore::DrawLengthKey()
1193 // Use fixed colours for each length so it's directly visually comparable
1195 num_bands
= GetNumColourBands();
1196 for (int band
= 0; band
< num_bands
; ++band
) {
1197 double len
= pow(10, LOG_LEN_MAX
* band
/ (num_bands
- 1));
1199 len
/= METRES_PER_FOOT
;
1201 key_legends
[band
].Printf(wxT("%.1f"), len
);
1204 DrawColourKey(num_bands
, wxString(), wmsg(m_Metric
? /*m*/424: /*ft*/428));
1207 void GfxCore::DrawScaleBar()
1209 // Draw the scalebar.
1210 if (GetPerspective()) return;
1212 // Calculate how many metres of survey are currently displayed across the
1214 Double across_screen
= SurveyUnitsAcrossViewport();
1216 double f
= double(GetClinoXPosition() - INDICATOR_BOX_SIZE
/ 2 - SCALE_BAR_OFFSET_X
) / GetXSize();
1219 } else if (f
< 0.5) {
1220 // Stop it getting squeezed to nothing.
1221 // FIXME: In this case we should probably move the compass and clino up
1222 // to make room rather than letting stuff overlap.
1226 // Convert to imperial measurements if required.
1227 Double multiplier
= 1.0;
1229 across_screen
/= METRES_PER_FOOT
;
1230 multiplier
= METRES_PER_FOOT
;
1231 if (across_screen
>= 5280.0 / f
) {
1232 across_screen
/= 5280.0;
1233 multiplier
*= 5280.0;
1237 // Calculate the length of the scale bar.
1238 Double size_snap
= pow(10.0, floor(log10(f
* across_screen
)));
1239 Double t
= across_screen
* f
/ size_snap
;
1242 } else if (t
>= 2.0) {
1246 if (!m_Metric
) size_snap
*= multiplier
;
1248 // Actual size of the thing in pixels:
1249 int size
= int((size_snap
/ SurveyUnitsAcrossViewport()) * GetXSize());
1250 m_ScaleBarWidth
= size
;
1253 const int end_y
= SCALE_BAR_OFFSET_Y
+ SCALE_BAR_HEIGHT
;
1254 int interval
= size
/ 10;
1256 gla_colour col
= col_WHITE
;
1257 for (int ix
= 0; ix
< 10; ix
++) {
1258 int x
= SCALE_BAR_OFFSET_X
+ int(ix
* ((Double
) size
/ 10.0));
1260 DrawRectangle(col
, col
, x
, end_y
, interval
+ 2, SCALE_BAR_HEIGHT
);
1262 col
= (col
== col_WHITE
) ? col_GREY
: col_WHITE
;
1269 Double km
= size_snap
* 1e-3;
1272 /* TRANSLATORS: abbreviation for "kilometres" (unit of length),
1275 * If there should be a space between the number and this, include
1276 * one in the translation. */
1278 } else if (size_snap
>= 1.0) {
1279 /* TRANSLATORS: abbreviation for "metres" (unit of length), used
1282 * If there should be a space between the number and this, include
1283 * one in the translation. */
1287 /* TRANSLATORS: abbreviation for "centimetres" (unit of length),
1290 * If there should be a space between the number and this, include
1291 * one in the translation. */
1295 size_snap
/= METRES_PER_FOOT
;
1296 Double miles
= size_snap
/ 5280.0;
1299 if (size_snap
>= 2.0) {
1300 /* TRANSLATORS: abbreviation for "miles" (unit of length,
1301 * plural), used e.g. "2 miles".
1303 * If there should be a space between the number and this,
1304 * include one in the translation. */
1305 units
= /* miles*/426;
1307 /* TRANSLATORS: abbreviation for "mile" (unit of length,
1308 * singular), used e.g. "1 mile".
1310 * If there should be a space between the number and this,
1311 * include one in the translation. */
1312 units
= /* mile*/427;
1314 } else if (size_snap
>= 1.0) {
1315 /* TRANSLATORS: abbreviation for "feet" (unit of length), used e.g.
1318 * If there should be a space between the number and this, include
1319 * one in the translation. */
1323 /* TRANSLATORS: abbreviation for "inches" (unit of length), used
1326 * If there should be a space between the number and this, include
1327 * one in the translation. */
1331 if (size_snap
>= 1.0) {
1332 str
.Printf(wxT("%.f%s"), size_snap
, wmsg(units
).c_str());
1334 int sf
= -(int)floor(log10(size_snap
));
1335 str
.Printf(wxT("%.*f%s"), sf
, size_snap
, wmsg(units
).c_str());
1338 int text_width
, text_height
;
1339 GetTextExtent(str
, &text_width
, &text_height
);
1340 const int text_y
= end_y
- text_height
+ 1;
1341 SetColour(TEXT_COLOUR
);
1342 DrawIndicatorText(SCALE_BAR_OFFSET_X
, text_y
, wxT("0"));
1343 DrawIndicatorText(SCALE_BAR_OFFSET_X
+ size
- text_width
, text_y
, str
);
1346 bool GfxCore::CheckHitTestGrid(const wxPoint
& point
, bool centre
)
1348 if (Animating()) return false;
1350 if (point
.x
< 0 || point
.x
>= GetXSize() ||
1351 point
.y
< 0 || point
.y
>= GetYSize()) {
1357 if (!m_HitTestGridValid
) CreateHitTestGrid();
1359 int grid_x
= point
.x
* HITTEST_SIZE
/ (GetXSize() + 1);
1360 int grid_y
= point
.y
* HITTEST_SIZE
/ (GetYSize() + 1);
1362 LabelInfo
*best
= NULL
;
1363 int dist_sqrd
= sqrd_measure_threshold
;
1364 int square
= grid_x
+ grid_y
* HITTEST_SIZE
;
1365 list
<LabelInfo
*>::iterator iter
= m_PointGrid
[square
].begin();
1367 while (iter
!= m_PointGrid
[square
].end()) {
1368 LabelInfo
*pt
= *iter
++;
1372 Transform(*pt
, &cx
, &cy
, &cz
);
1374 cy
= GetYSize() - cy
;
1376 int dx
= point
.x
- int(cx
);
1378 if (ds
>= dist_sqrd
) continue;
1379 int dy
= point
.y
- int(cy
);
1382 if (ds
>= dist_sqrd
) continue;
1391 m_Parent
->ShowInfo(best
, m_there
);
1393 // FIXME: allow Ctrl-Click to not set there or something?
1395 WarpPointer(GetXSize() / 2, GetYSize() / 2);
1397 m_Parent
->SelectTreeItem(best
);
1400 // Left-clicking not on a survey cancels the measuring line.
1402 ClearTreeSelection();
1404 m_Parent
->ShowInfo(best
, m_there
);
1406 ReverseTransform(point
.x
, GetYSize() - point
.y
, &x
, &y
, &z
);
1407 temp_here
.assign(Vector3(x
, y
, z
));
1408 SetHere(&temp_here
);
1415 void GfxCore::OnSize(wxSizeEvent
& event
)
1417 // Handle a change in window size.
1418 wxSize size
= event
.GetSize();
1420 if (size
.GetWidth() <= 0 || size
.GetHeight() <= 0) {
1421 // Before things are fully initialised, we sometimes get a bogus
1422 // resize message...
1423 // FIXME have changes in MainFrm cured this? It still happens with
1424 // 1.0.32 and wxGTK 2.5.2 (load a file from the command line).
1425 // With 1.1.6 and wxGTK 2.4.2 we only get negative sizes if MainFrm
1426 // is resized such that the GfxCore window isn't visible.
1427 //printf("OnSize(%d,%d)\n", size.GetWidth(), size.GetHeight());
1433 if (m_DoneFirstShow
) {
1436 m_HitTestGridValid
= false;
1442 void GfxCore::DefaultParameters()
1444 // Set default viewing parameters.
1447 if (!m_Parent
->HasUndergroundLegs()) {
1448 if (m_Parent
->HasSurfaceLegs()) {
1449 // If there are surface legs, but no underground legs, turn
1450 // surface surveys on.
1453 // If there are no legs (e.g. after loading a .pos file), turn
1460 if (m_Parent
->IsExtendedElevation()) {
1463 m_TiltAngle
= -90.0;
1466 SetRotation(m_PanAngle
, m_TiltAngle
);
1467 SetTranslation(Vector3());
1469 m_RotationStep
= 30.0;
1472 m_Entrances
= false;
1474 m_ExportedPts
= false;
1476 m_BoundingBox
= false;
1478 if (GetPerspective()) TogglePerspective();
1480 // Set the initial scale.
1481 SetScale(initial_scale
);
1484 void GfxCore::Defaults()
1486 // Restore default scale, rotation and translation parameters.
1487 DefaultParameters();
1489 // Invalidate all the cached lists.
1490 GLACanvas::FirstShow();
1495 void GfxCore::Animate()
1497 // Don't show pointer coordinates while animating.
1498 // FIXME : only do this when we *START* animating! Use a static copy
1499 // of the value of "Animating()" last time we were here to track this?
1500 // MainFrm now checks if we're trying to clear already cleared labels
1501 // and just returns, but it might be simpler to check here!
1503 m_Parent
->ShowInfo();
1507 ReadPixels(movie
->GetWidth(), movie
->GetHeight(), movie
->GetBuffer());
1508 if (!movie
->AddFrame()) {
1509 wxGetApp().ReportError(wxString(movie
->get_error_string(), wxConvUTF8
));
1512 presentation_mode
= 0;
1515 t
= 1000 / 25; // 25 frames per second
1517 static long t_prev
= 0;
1519 // Avoid redrawing twice in the same frame.
1520 long delta_t
= (t_prev
== 0 ? 1000 / MAX_FRAMERATE
: t
- t_prev
);
1521 if (delta_t
< 1000 / MAX_FRAMERATE
)
1524 if (presentation_mode
== PLAYING
&& pres_speed
!= 0.0)
1528 if (presentation_mode
== PLAYING
&& pres_speed
!= 0.0) {
1529 // FIXME: It would probably be better to work relative to the time we
1530 // passed the last mark, but that's complicated by the speed
1531 // potentially changing (or even the direction of playback reversing)
1532 // at any point during playback.
1533 Double tick
= t
* 0.001 * fabs(pres_speed
);
1534 while (tick
>= next_mark_time
) {
1535 tick
-= next_mark_time
;
1536 this_mark_total
= 0;
1537 PresentationMark prev_mark
= next_mark
;
1538 if (prev_mark
.angle
< 0) prev_mark
.angle
+= 360.0;
1539 else if (prev_mark
.angle
>= 360.0) prev_mark
.angle
-= 360.0;
1541 next_mark
= m_Parent
->GetPresMark(MARK_PREV
);
1543 next_mark
= m_Parent
->GetPresMark(MARK_NEXT
);
1544 if (!next_mark
.is_valid()) {
1546 presentation_mode
= 0;
1547 if (movie
&& !movie
->Close()) {
1548 wxGetApp().ReportError(wxString(movie
->get_error_string(), wxConvUTF8
));
1555 double tmp
= (pres_reverse
? prev_mark
.time
: next_mark
.time
);
1557 next_mark_time
= tmp
;
1559 double d
= (next_mark
- prev_mark
).magnitude();
1560 // FIXME: should ignore component of d which is unseen in
1561 // non-perspective mode?
1562 next_mark_time
= sqrd(d
/ 30.0);
1563 double a
= next_mark
.angle
- prev_mark
.angle
;
1565 next_mark
.angle
-= 360.0;
1567 } else if (a
< -180.0) {
1568 next_mark
.angle
+= 360.0;
1573 next_mark_time
+= sqrd(a
/ 60.0);
1574 double ta
= fabs(next_mark
.tilt_angle
- prev_mark
.tilt_angle
);
1575 next_mark_time
+= sqrd(ta
/ 60.0);
1576 double s
= fabs(log(next_mark
.scale
) - log(prev_mark
.scale
));
1577 next_mark_time
+= sqrd(s
/ 2.0);
1578 next_mark_time
= sqrt(next_mark_time
);
1579 // was: next_mark_time = max(max(d / 30, s / 2), max(a, ta) / 60);
1580 //printf("*** %.6f from (\nd: %.6f\ns: %.6f\na: %.6f\nt: %.6f )\n",
1581 // next_mark_time, d/30.0, s/2.0, a/60.0, ta/60.0);
1582 if (tmp
< 0) next_mark_time
/= -tmp
;
1586 if (presentation_mode
) {
1587 // Advance position towards next_mark
1588 double p
= tick
/ next_mark_time
;
1590 PresentationMark here
= GetView();
1591 if (next_mark
.angle
< 0) {
1592 if (here
.angle
>= next_mark
.angle
+ 360.0)
1593 here
.angle
-= 360.0;
1594 } else if (next_mark
.angle
>= 360.0) {
1595 if (here
.angle
<= next_mark
.angle
- 360.0)
1596 here
.angle
+= 360.0;
1598 here
.assign(q
* here
+ p
* next_mark
);
1599 here
.angle
= q
* here
.angle
+ p
* next_mark
.angle
;
1600 if (here
.angle
< 0) here
.angle
+= 360.0;
1601 else if (here
.angle
>= 360.0) here
.angle
-= 360.0;
1602 here
.tilt_angle
= q
* here
.tilt_angle
+ p
* next_mark
.tilt_angle
;
1603 here
.scale
= exp(q
* log(here
.scale
) + p
* log(next_mark
.scale
));
1605 this_mark_total
+= tick
;
1606 next_mark_time
-= tick
;
1615 Double step
= base_pan
+ (t
- base_pan_time
) * 1e-3 * m_RotationStep
- m_PanAngle
;
1619 if (m_SwitchingTo
== PLAN
) {
1620 // When switching to plan view...
1621 Double step
= base_tilt
- (t
- base_tilt_time
) * 1e-3 * 90.0 - m_TiltAngle
;
1623 if (m_TiltAngle
== -90.0) {
1626 } else if (m_SwitchingTo
== ELEVATION
) {
1627 // When switching to elevation view...
1629 if (m_TiltAngle
> 0.0) {
1630 step
= base_tilt
- (t
- base_tilt_time
) * 1e-3 * 90.0 - m_TiltAngle
;
1632 step
= base_tilt
+ (t
- base_tilt_time
) * 1e-3 * 90.0 - m_TiltAngle
;
1634 if (fabs(step
) >= fabs(m_TiltAngle
)) {
1636 step
= -m_TiltAngle
;
1639 } else if (m_SwitchingTo
) {
1640 // Rotate the shortest way around to the destination angle. If we're
1641 // 180 off, we favour turning anticlockwise, as auto-rotation does by
1643 Double target
= (m_SwitchingTo
- NORTH
) * 90;
1644 Double diff
= target
- m_PanAngle
;
1645 diff
= fmod(diff
, 360);
1648 else if (diff
> 180)
1650 if (m_RotationStep
< 0 && diff
== 180.0)
1652 Double step
= base_pan
- m_PanAngle
;
1653 Double delta
= (t
- base_pan_time
) * 1e-3 * fabs(m_RotationStep
);
1659 step
= fmod(step
, 360);
1662 else if (step
> 180)
1664 if (fabs(step
) >= fabs(diff
)) {
1674 // How much to allow around the box - this is because of the ring shape
1675 // at one end of the line.
1676 static const int HIGHLIGHTED_PT_SIZE
= 2; // FIXME: tie in to blob and ring size
1677 #define MARGIN (HIGHLIGHTED_PT_SIZE * 2 + 1)
1678 void GfxCore::RefreshLine(const Point
*a
, const Point
*b
, const Point
*c
)
1684 // FIXME: We get odd redraw artifacts if we just update the line, and
1685 // redrawing the whole scene doesn't actually seem to be measurably
1686 // slower. That may not be true with software rendering though...
1689 // Best of all might be to copy the window contents before we draw the
1690 // line, then replace each time we redraw.
1692 // Calculate the minimum rectangle which includes the old and new
1693 // measuring lines to minimise the redraw time
1694 int l
= INT_MAX
, r
= INT_MIN
, u
= INT_MIN
, d
= INT_MAX
;
1697 if (!Transform(*a
, &X
, &Y
, &Z
)) {
1701 int y
= GetYSize() - 1 - int(Y
);
1709 if (!Transform(*b
, &X
, &Y
, &Z
)) {
1713 int y
= GetYSize() - 1 - int(Y
);
1721 if (!Transform(*c
, &X
, &Y
, &Z
)) {
1725 int y
= GetYSize() - 1 - int(Y
);
1736 RefreshRect(wxRect(l
, d
, r
- l
, u
- d
), false);
1740 void GfxCore::SetHereFromTree(const LabelInfo
* p
)
1743 m_Parent
->ShowInfo(m_here
, m_there
);
1746 void GfxCore::SetHere()
1748 if (!m_here
) return;
1749 bool line_active
= MeasuringLineActive();
1750 const LabelInfo
* old
= m_here
;
1752 if (line_active
|| MeasuringLineActive())
1753 RefreshLine(old
, m_there
, m_here
);
1756 void GfxCore::SetHere(const LabelInfo
*p
)
1758 bool line_active
= MeasuringLineActive();
1759 const LabelInfo
* old
= m_here
;
1761 if (line_active
|| MeasuringLineActive())
1762 RefreshLine(old
, m_there
, m_here
);
1765 void GfxCore::SetThere()
1767 if (!m_there
) return;
1768 const LabelInfo
* old
= m_there
;
1770 RefreshLine(m_here
, old
, m_there
);
1773 void GfxCore::SetThere(const LabelInfo
* p
)
1775 const LabelInfo
* old
= m_there
;
1777 RefreshLine(m_here
, old
, m_there
);
1780 void GfxCore::CreateHitTestGrid()
1783 // Initialise hit-test grid.
1784 m_PointGrid
= new list
<LabelInfo
*>[HITTEST_SIZE
* HITTEST_SIZE
];
1786 // Clear hit-test grid.
1787 for (int i
= 0; i
< HITTEST_SIZE
* HITTEST_SIZE
; i
++) {
1788 m_PointGrid
[i
].clear();
1793 list
<LabelInfo
*>::const_iterator pos
= m_Parent
->GetLabels();
1794 list
<LabelInfo
*>::const_iterator end
= m_Parent
->GetLabelsEnd();
1795 while (pos
!= end
) {
1796 LabelInfo
* label
= *pos
++;
1798 if (!((m_Surface
&& label
->IsSurface()) ||
1799 (m_Legs
&& label
->IsUnderground()) ||
1800 (!label
->IsSurface() && !label
->IsUnderground()))) {
1801 // if this station isn't to be displayed, skip to the next
1802 // (last case is for stns with no legs attached)
1806 // Calculate screen coordinates.
1808 Transform(*label
, &cx
, &cy
, &cz
);
1809 if (cx
< 0 || cx
>= GetXSize()) continue;
1810 if (cy
< 0 || cy
>= GetYSize()) continue;
1812 cy
= GetYSize() - cy
;
1814 // On-screen, so add to hit-test grid...
1815 int grid_x
= int(cx
* HITTEST_SIZE
/ (GetXSize() + 1));
1816 int grid_y
= int(cy
* HITTEST_SIZE
/ (GetYSize() + 1));
1818 m_PointGrid
[grid_x
+ grid_y
* HITTEST_SIZE
].push_back(label
);
1821 m_HitTestGridValid
= true;
1825 // Methods for controlling the orientation of the survey
1828 void GfxCore::TurnCave(Double angle
)
1830 // Turn the cave around its z-axis by a given angle.
1832 m_PanAngle
+= angle
;
1833 // Wrap to range [0, 360):
1834 m_PanAngle
= fmod(m_PanAngle
, 360.0);
1835 if (m_PanAngle
< 0.0) {
1836 m_PanAngle
+= 360.0;
1839 m_HitTestGridValid
= false;
1840 if (m_here
&& m_here
== &temp_here
) SetHere();
1842 SetRotation(m_PanAngle
, m_TiltAngle
);
1845 void GfxCore::TurnCaveTo(Double angle
)
1848 // If we're rotating, jump to the specified angle.
1849 TurnCave(angle
- m_PanAngle
);
1854 int new_switching_to
= ((int)angle
) / 90 + NORTH
;
1855 if (new_switching_to
== m_SwitchingTo
) {
1856 // A second order to switch takes us there right away
1857 TurnCave(angle
- m_PanAngle
);
1862 m_SwitchingTo
= new_switching_to
;
1866 void GfxCore::TiltCave(Double tilt_angle
)
1868 // Tilt the cave by a given angle.
1869 if (m_TiltAngle
+ tilt_angle
> 90.0) {
1871 } else if (m_TiltAngle
+ tilt_angle
< -90.0) {
1872 m_TiltAngle
= -90.0;
1874 m_TiltAngle
+= tilt_angle
;
1877 m_HitTestGridValid
= false;
1878 if (m_here
&& m_here
== &temp_here
) SetHere();
1880 SetRotation(m_PanAngle
, m_TiltAngle
);
1883 void GfxCore::TranslateCave(int dx
, int dy
)
1885 AddTranslationScreenCoordinates(dx
, dy
);
1886 m_HitTestGridValid
= false;
1888 if (m_here
&& m_here
== &temp_here
) SetHere();
1893 void GfxCore::DragFinished()
1895 m_MouseOutsideCompass
= m_MouseOutsideElev
= false;
1899 void GfxCore::ClearCoords()
1901 m_Parent
->ClearCoords();
1904 void GfxCore::SetCoords(wxPoint point
)
1906 // We can't work out 2D coordinates from a perspective view, and it
1907 // doesn't really make sense to show coordinates while we're animating.
1908 if (GetPerspective() || Animating()) return;
1910 // Update the coordinate or altitude display, given the (x, y) position in
1911 // window coordinates. The relevant display is updated depending on
1912 // whether we're in plan or elevation view.
1917 ReverseTransform(point
.x
, GetYSize() - 1 - point
.y
, &cx
, &cy
, &cz
);
1919 if (ShowingPlan()) {
1920 m_Parent
->SetCoords(cx
+ m_Parent
->GetOffset().GetX(),
1921 cy
+ m_Parent
->GetOffset().GetY(),
1923 } else if (ShowingElevation()) {
1924 m_Parent
->SetAltitude(cz
+ m_Parent
->GetOffset().GetZ(),
1927 m_Parent
->ClearCoords();
1931 int GfxCore::GetCompassWidth() const
1933 static int result
= 0;
1935 result
= INDICATOR_BOX_SIZE
;
1937 const wxString
& msg
= wmsg(/*Facing*/203);
1938 GetTextExtent(msg
, &width
, NULL
);
1939 if (width
> result
) result
= width
;
1944 int GfxCore::GetClinoWidth() const
1946 static int result
= 0;
1948 result
= INDICATOR_BOX_SIZE
;
1950 const wxString
& msg1
= wmsg(/*Plan*/432);
1951 GetTextExtent(msg1
, &width
, NULL
);
1952 if (width
> result
) result
= width
;
1953 const wxString
& msg2
= wmsg(/*Kiwi Plan*/433);
1954 GetTextExtent(msg2
, &width
, NULL
);
1955 if (width
> result
) result
= width
;
1956 const wxString
& msg3
= wmsg(/*Elevation*/118);
1957 GetTextExtent(msg3
, &width
, NULL
);
1958 if (width
> result
) result
= width
;
1963 int GfxCore::GetCompassXPosition() const
1965 // Return the x-coordinate of the centre of the compass in window
1967 return GetXSize() - INDICATOR_OFFSET_X
- GetCompassWidth() / 2;
1970 int GfxCore::GetClinoXPosition() const
1972 // Return the x-coordinate of the centre of the compass in window
1974 return GetXSize() - GetClinoOffset() - GetClinoWidth() / 2;
1977 int GfxCore::GetIndicatorYPosition() const
1979 // Return the y-coordinate of the centre of the indicators in window
1981 return GetYSize() - INDICATOR_OFFSET_Y
- INDICATOR_BOX_SIZE
/ 2;
1984 int GfxCore::GetIndicatorRadius() const
1986 // Return the radius of each indicator.
1987 return (INDICATOR_BOX_SIZE
- INDICATOR_MARGIN
* 2) / 2;
1990 bool GfxCore::PointWithinCompass(wxPoint point
) const
1992 // Determine whether a point (in window coordinates) lies within the
1994 if (!ShowingCompass()) return false;
1996 glaCoord dx
= point
.x
- GetCompassXPosition();
1997 glaCoord dy
= point
.y
- GetIndicatorYPosition();
1998 glaCoord radius
= GetIndicatorRadius();
2000 return (dx
* dx
+ dy
* dy
<= radius
* radius
);
2003 bool GfxCore::PointWithinClino(wxPoint point
) const
2005 // Determine whether a point (in window coordinates) lies within the clino.
2006 if (!ShowingClino()) return false;
2008 glaCoord dx
= point
.x
- GetClinoXPosition();
2009 glaCoord dy
= point
.y
- GetIndicatorYPosition();
2010 glaCoord radius
= GetIndicatorRadius();
2012 return (dx
* dx
+ dy
* dy
<= radius
* radius
);
2015 bool GfxCore::PointWithinScaleBar(wxPoint point
) const
2017 // Determine whether a point (in window coordinates) lies within the scale
2019 if (!ShowingScaleBar()) return false;
2021 return (point
.x
>= SCALE_BAR_OFFSET_X
&&
2022 point
.x
<= SCALE_BAR_OFFSET_X
+ m_ScaleBarWidth
&&
2023 point
.y
<= GetYSize() - SCALE_BAR_OFFSET_Y
- SCALE_BAR_HEIGHT
&&
2024 point
.y
>= GetYSize() - SCALE_BAR_OFFSET_Y
- SCALE_BAR_HEIGHT
*2);
2027 bool GfxCore::PointWithinColourKey(wxPoint point
) const
2029 // Determine whether a point (in window coordinates) lies within the key.
2030 point
.x
-= GetXSize() - KEY_OFFSET_X
;
2031 point
.y
= KEY_OFFSET_Y
- point
.y
;
2032 return (point
.x
>= key_lowerleft
[m_ColourBy
].x
&& point
.x
<= 0 &&
2033 point
.y
>= key_lowerleft
[m_ColourBy
].y
&& point
.y
<= 0);
2036 void GfxCore::SetCompassFromPoint(wxPoint point
)
2038 // Given a point in window coordinates, set the heading of the survey. If
2039 // the point is outside the compass, it snaps to 45 degree intervals;
2040 // otherwise it operates as normal.
2042 wxCoord dx
= point
.x
- GetCompassXPosition();
2043 wxCoord dy
= point
.y
- GetIndicatorYPosition();
2044 wxCoord radius
= GetIndicatorRadius();
2046 double angle
= deg(atan2(double(dx
), double(dy
))) - 180.0;
2047 if (dx
* dx
+ dy
* dy
<= radius
* radius
) {
2048 TurnCave(angle
- m_PanAngle
);
2049 m_MouseOutsideCompass
= false;
2051 TurnCave(int(angle
/ 45.0) * 45.0 - m_PanAngle
);
2052 m_MouseOutsideCompass
= true;
2058 void GfxCore::SetClinoFromPoint(wxPoint point
)
2060 // Given a point in window coordinates, set the elevation of the survey.
2061 // If the point is outside the clino, it snaps to 90 degree intervals;
2062 // otherwise it operates as normal.
2064 glaCoord dx
= point
.x
- GetClinoXPosition();
2065 glaCoord dy
= point
.y
- GetIndicatorYPosition();
2066 glaCoord radius
= GetIndicatorRadius();
2068 if (dx
>= 0 && dx
* dx
+ dy
* dy
<= radius
* radius
) {
2069 TiltCave(-deg(atan2(double(dy
), double(dx
))) - m_TiltAngle
);
2070 m_MouseOutsideElev
= false;
2071 } else if (dy
>= INDICATOR_MARGIN
) {
2072 TiltCave(-90.0 - m_TiltAngle
);
2073 m_MouseOutsideElev
= true;
2074 } else if (dy
<= -INDICATOR_MARGIN
) {
2075 TiltCave(90.0 - m_TiltAngle
);
2076 m_MouseOutsideElev
= true;
2078 TiltCave(-m_TiltAngle
);
2079 m_MouseOutsideElev
= true;
2085 void GfxCore::SetScaleBarFromOffset(wxCoord dx
)
2087 // Set the scale of the survey, given an offset as to how much the mouse has
2088 // been dragged over the scalebar since the last scale change.
2090 SetScale((m_ScaleBarWidth
+ dx
) * m_Scale
/ m_ScaleBarWidth
);
2094 void GfxCore::RedrawIndicators()
2096 // Redraw the compass and clino indicators.
2098 int total_width
= GetCompassWidth() + INDICATOR_GAP
+ GetClinoWidth();
2099 RefreshRect(wxRect(GetXSize() - INDICATOR_OFFSET_X
- total_width
,
2100 GetYSize() - INDICATOR_OFFSET_Y
- INDICATOR_BOX_SIZE
,
2102 INDICATOR_BOX_SIZE
), false);
2105 void GfxCore::StartRotation()
2107 // Start the survey rotating.
2109 if (m_SwitchingTo
>= NORTH
)
2115 void GfxCore::ToggleRotation()
2117 // Toggle the survey rotation on/off.
2126 void GfxCore::StopRotation()
2128 // Stop the survey rotating.
2134 bool GfxCore::IsExtendedElevation() const
2136 return m_Parent
->IsExtendedElevation();
2139 void GfxCore::ReverseRotation()
2141 // Reverse the direction of rotation.
2143 m_RotationStep
= -m_RotationStep
;
2148 void GfxCore::RotateSlower(bool accel
)
2150 // Decrease the speed of rotation, optionally by an increased amount.
2151 if (fabs(m_RotationStep
) == 1.0)
2154 m_RotationStep
*= accel
? (1 / 1.44) : (1 / 1.2);
2156 if (fabs(m_RotationStep
) < 1.0) {
2157 m_RotationStep
= (m_RotationStep
> 0 ? 1.0 : -1.0);
2163 void GfxCore::RotateFaster(bool accel
)
2165 // Increase the speed of rotation, optionally by an increased amount.
2166 if (fabs(m_RotationStep
) == 180.0)
2169 m_RotationStep
*= accel
? 1.44 : 1.2;
2170 if (fabs(m_RotationStep
) > 180.0) {
2171 m_RotationStep
= (m_RotationStep
> 0 ? 180.0 : -180.0);
2177 void GfxCore::SwitchToElevation()
2179 // Perform an animated switch to elevation view.
2181 if (m_SwitchingTo
!= ELEVATION
) {
2183 m_SwitchingTo
= ELEVATION
;
2185 // A second order to switch takes us there right away
2186 TiltCave(-m_TiltAngle
);
2192 void GfxCore::SwitchToPlan()
2194 // Perform an animated switch to plan view.
2196 if (m_SwitchingTo
!= PLAN
) {
2198 m_SwitchingTo
= PLAN
;
2200 // A second order to switch takes us there right away
2201 TiltCave(-90.0 - m_TiltAngle
);
2207 void GfxCore::SetViewTo(Double xmin
, Double xmax
, Double ymin
, Double ymax
, Double zmin
, Double zmax
)
2210 SetTranslation(-Vector3((xmin
+ xmax
) / 2, (ymin
+ ymax
) / 2, (zmin
+ zmax
) / 2));
2211 Double scale
= HUGE_VAL
;
2212 const Vector3 ext
= m_Parent
->GetExtent();
2214 Double s
= ext
.GetX() / (xmax
- xmin
);
2215 if (s
< scale
) scale
= s
;
2218 Double s
= ext
.GetY() / (ymax
- ymin
);
2219 if (s
< scale
) scale
= s
;
2221 if (!ShowingPlan() && zmax
> zmin
) {
2222 Double s
= ext
.GetZ() / (zmax
- zmin
);
2223 if (s
< scale
) scale
= s
;
2225 if (scale
!= HUGE_VAL
) SetScale(scale
);
2229 bool GfxCore::CanRaiseViewpoint() const
2231 // Determine if the survey can be viewed from a higher angle of elevation.
2233 return GetPerspective() ? (m_TiltAngle
< 90.0) : (m_TiltAngle
> -90.0);
2236 bool GfxCore::CanLowerViewpoint() const
2238 // Determine if the survey can be viewed from a lower angle of elevation.
2240 return GetPerspective() ? (m_TiltAngle
> -90.0) : (m_TiltAngle
< 90.0);
2243 bool GfxCore::HasDepth() const
2245 return m_Parent
->GetDepthExtent() == 0.0;
2248 bool GfxCore::HasErrorInformation() const
2250 return m_Parent
->HasErrorInformation();
2253 bool GfxCore::HasDateInformation() const
2255 return m_Parent
->GetDateMin() >= 0;
2258 bool GfxCore::ShowingPlan() const
2260 // Determine if the survey is in plan view.
2262 return (m_TiltAngle
== -90.0);
2265 bool GfxCore::ShowingElevation() const
2267 // Determine if the survey is in elevation view.
2269 return (m_TiltAngle
== 0.0);
2272 bool GfxCore::ShowingMeasuringLine() const
2274 // Determine if the measuring line is being shown. Only check if "there"
2275 // is valid, since that means the measuring line anchor is out.
2280 void GfxCore::ToggleFlag(bool* flag
, int update
)
2283 if (update
== UPDATE_BLOBS
) {
2285 } else if (update
== UPDATE_BLOBS_AND_CROSSES
) {
2287 InvalidateList(LIST_CROSSES
);
2288 m_HitTestGridValid
= false;
2293 int GfxCore::GetNumEntrances() const
2295 return m_Parent
->GetNumEntrances();
2298 int GfxCore::GetNumFixedPts() const
2300 return m_Parent
->GetNumFixedPts();
2303 int GfxCore::GetNumExportedPts() const
2305 return m_Parent
->GetNumExportedPts();
2308 void GfxCore::ToggleTerrain()
2310 ToggleFlag(&m_Terrain
);
2311 if (m_Terrain
&& !dem
) {
2312 wxCommandEvent dummy
;
2313 m_Parent
->OnOpenTerrain(dummy
);
2317 void GfxCore::ToggleFatFinger()
2319 if (sqrd_measure_threshold
== sqrd(MEASURE_THRESHOLD
)) {
2320 sqrd_measure_threshold
= sqrd(5 * MEASURE_THRESHOLD
);
2321 wxMessageBox(wxT("Fat finger enabled"), wxT("Aven Debug"), wxOK
| wxICON_INFORMATION
);
2323 sqrd_measure_threshold
= sqrd(MEASURE_THRESHOLD
);
2324 wxMessageBox(wxT("Fat finger disabled"), wxT("Aven Debug"), wxOK
| wxICON_INFORMATION
);
2328 void GfxCore::ClearTreeSelection()
2330 m_Parent
->ClearTreeSelection();
2333 void GfxCore::CentreOn(const Point
&p
)
2336 m_HitTestGridValid
= false;
2341 void GfxCore::ForceRefresh()
2346 void GfxCore::GenerateList(unsigned int l
)
2357 case LIST_CLINO_BACK
:
2360 case LIST_SCALE_BAR
:
2363 case LIST_DEPTH_KEY
:
2369 case LIST_ERROR_KEY
:
2372 case LIST_GRADIENT_KEY
:
2375 case LIST_LENGTH_KEY
:
2378 case LIST_UNDERGROUND_LEGS
:
2379 GenerateDisplayList();
2382 GenerateDisplayListTubes();
2384 case LIST_SURFACE_LEGS
:
2385 GenerateDisplayListSurface();
2388 GenerateBlobsDisplayList();
2390 case LIST_CROSSES
: {
2392 SetColour(col_LIGHT_GREY
);
2393 list
<LabelInfo
*>::const_iterator pos
= m_Parent
->GetLabels();
2394 while (pos
!= m_Parent
->GetLabelsEnd()) {
2395 const LabelInfo
* label
= *pos
++;
2397 if ((m_Surface
&& label
->IsSurface()) ||
2398 (m_Legs
&& label
->IsUnderground()) ||
2399 (!label
->IsSurface() && !label
->IsUnderground())) {
2400 // Check if this station should be displayed
2401 // (last case is for stns with no legs attached)
2402 DrawCross(label
->GetX(), label
->GetY(), label
->GetZ());
2412 GenerateDisplayListShadow();
2423 void GfxCore::ToggleSmoothShading()
2425 GLACanvas::ToggleSmoothShading();
2426 InvalidateList(LIST_TUBES
);
2430 void GfxCore::GenerateDisplayList()
2432 // Generate the display list for the underground legs.
2433 list
<traverse
>::const_iterator trav
= m_Parent
->traverses_begin();
2434 list
<traverse
>::const_iterator tend
= m_Parent
->traverses_end();
2436 if (m_Splays
== SPLAYS_SHOW_FADED
) {
2438 while (trav
!= tend
) {
2439 if ((*trav
).isSplay
)
2440 (this->*AddPoly
)(*trav
);
2444 trav
= m_Parent
->traverses_begin();
2447 while (trav
!= tend
) {
2448 if (m_Splays
== SPLAYS_SHOW_NORMAL
|| !(*trav
).isSplay
)
2449 (this->*AddPoly
)(*trav
);
2454 void GfxCore::GenerateDisplayListTubes()
2456 // Generate the display list for the tubes.
2457 list
<vector
<XSect
> >::iterator trav
= m_Parent
->tubes_begin();
2458 list
<vector
<XSect
> >::iterator tend
= m_Parent
->tubes_end();
2459 while (trav
!= tend
) {
2465 void GfxCore::GenerateDisplayListSurface()
2467 // Generate the display list for the surface legs.
2468 EnableDashedLines();
2469 list
<traverse
>::const_iterator trav
= m_Parent
->surface_traverses_begin();
2470 list
<traverse
>::const_iterator tend
= m_Parent
->surface_traverses_end();
2471 while (trav
!= tend
) {
2472 if (m_ColourBy
== COLOUR_BY_ERROR
) {
2473 AddPolylineError(*trav
);
2479 DisableDashedLines();
2482 void GfxCore::GenerateDisplayListShadow()
2484 SetColour(col_BLACK
);
2485 list
<traverse
>::const_iterator trav
= m_Parent
->traverses_begin();
2486 list
<traverse
>::const_iterator tend
= m_Parent
->traverses_end();
2487 while (trav
!= tend
) {
2488 AddPolylineShadow(*trav
);
2494 GfxCore::parse_hgt_filename(const wxString
& lc_name
)
2496 char * leaf
= leaf_from_fnm(lc_name
.utf8_str());
2497 const char * p
= leaf
;
2500 o_y
= strtoul(p
, &q
, 10);
2506 o_x
= strtoul(p
, &q
, 10);
2510 nodata_value
= -32768;
2515 GfxCore::parse_hdr(wxInputStream
& is
, unsigned long & skipbytes
)
2517 unsigned long nbits
;
2521 while ((ch
= is
.GetC()) != wxEOF
) {
2522 if (ch
== '\n' || ch
== '\r') break;
2525 #define CHECK(X, COND) \
2526 } else if (line.StartsWith(wxT(X " "))) { \
2527 size_t v = line.find_first_not_of(wxT(' '), sizeof(X)); \
2528 if (v == line.npos || !(COND)) { \
2529 err += wxT("Unexpected value for " X); \
2532 unsigned long dummy
;
2534 // I = little-endian; M = big-endian
2535 CHECK("BYTEORDER", (bigendian
= (line
[v
] == 'M')) || line
[v
] == 'I')
2536 CHECK("LAYOUT", line
.substr(v
) == wxT("BIL"))
2537 CHECK("NROWS", line
.substr(v
).ToCULong(&dem_width
))
2538 CHECK("NCOLS", line
.substr(v
).ToCULong(&dem_height
))
2539 CHECK("NBANDS", line
.substr(v
).ToCULong(&dummy
) && dummy
== 1)
2540 CHECK("NBITS", line
.substr(v
).ToCULong(&nbits
) && nbits
== 16)
2541 //: BANDROWBYTES 7202
2542 //: TOTALROWBYTES 7202
2543 // PIXELTYPE is a GDAL extension, so may not be present.
2544 CHECK("PIXELTYPE", line
.substr(v
) == wxT("SIGNEDINT"))
2545 CHECK("ULXMAP", line
.substr(v
).ToCDouble(&o_x
))
2546 CHECK("ULYMAP", line
.substr(v
).ToCDouble(&o_y
))
2547 CHECK("XDIM", line
.substr(v
).ToCDouble(&step_x
))
2548 CHECK("YDIM", line
.substr(v
).ToCDouble(&step_y
))
2549 CHECK("NODATA", line
.substr(v
).ToCLong(&nodata_value
))
2550 CHECK("SKIPBYTES", line
.substr(v
).ToCULong(&skipbytes
))
2556 return ((nbits
+ 7) / 8) * dem_width
* dem_height
;
2560 GfxCore::read_bil(wxInputStream
& is
, size_t size
, unsigned long skipbytes
)
2562 bool know_size
= true;
2564 // If the stream doesn't know its size, GetSize() returns 0.
2565 size
= is
.GetSize();
2567 size
= DEFAULT_HGT_SIZE
;
2571 dem
= new unsigned short[size
/ 2];
2573 if (is
.SeekI(skipbytes
, wxFromStart
) == ::wxInvalidOffset
) {
2575 unsigned long to_read
= skipbytes
;
2576 if (size
< to_read
) to_read
= size
;
2577 is
.Read(reinterpret_cast<char *>(dem
), to_read
);
2578 size_t c
= is
.LastRead();
2580 wxMessageBox(wxT("Failed to skip terrain data header"));
2588 #if wxCHECK_VERSION(2,9,5)
2589 if (!is
.ReadAll(dem
, size
)) {
2591 // FIXME: On __WXMSW__ currently we fail to
2592 // read any data from files in zips.
2595 wxMessageBox(wxT("Failed to read terrain data"));
2598 size
= is
.LastRead();
2601 char * p
= reinterpret_cast<char *>(dem
);
2604 size_t c
= is
.LastRead();
2607 size
= DEFAULT_HGT_SIZE
- size
;
2613 wxMessageBox(wxT("Failed to read terrain data"));
2621 if (dem_width
== 0 && dem_height
== 0) {
2622 dem_width
= dem_height
= sqrt(size
/ 2);
2623 if (dem_width
* dem_height
* 2 != size
) {
2626 wxMessageBox(wxT("HGT format data doesn't form a square"));
2629 step_x
= step_y
= 1.0 / dem_width
;
2635 bool GfxCore::LoadDEM(const wxString
& file
)
2637 if (m_Parent
->m_cs_proj
.empty()) {
2638 wxMessageBox(wxT("No coordinate system specified in survey data"));
2646 // Default is to not skip any bytes.
2647 unsigned long skipbytes
= 0;
2648 // For .hgt files, default to using filesize to determine.
2649 dem_width
= dem_height
= 0;
2650 // ESRI say "The default byte order is the same as that of the host machine
2651 // executing the software", but that's stupid so we default to
2655 wxFileInputStream
fs(file
);
2657 wxMessageBox(wxT("Failed to open DEM file"));
2661 const wxString
& lc_file
= file
.Lower();
2662 if (lc_file
.EndsWith(wxT(".hgt"))) {
2663 parse_hgt_filename(lc_file
);
2664 read_bil(fs
, size
, skipbytes
);
2665 } else if (lc_file
.EndsWith(wxT(".bil"))) {
2666 wxString hdr_file
= file
;
2667 hdr_file
.replace(file
.size() - 4, 4, wxT(".hdr"));
2668 wxFileInputStream
hdr_is(hdr_file
);
2669 if (!hdr_is
.IsOk()) {
2670 wxMessageBox(wxT("Failed to open HDR file '") + hdr_file
+ wxT("'"));
2673 size
= parse_hdr(hdr_is
, skipbytes
);
2674 read_bil(fs
, size
, skipbytes
);
2675 } else if (lc_file
.EndsWith(wxT(".zip"))) {
2676 wxZipEntry
* ze_data
= NULL
;
2677 wxZipInputStream
zs(fs
);
2679 while ((ze
= zs
.GetNextEntry()) != NULL
) {
2681 const wxString
& lc_name
= ze
->GetName().Lower();
2682 if (!ze_data
&& lc_name
.EndsWith(wxT(".hgt"))) {
2683 // SRTM .hgt files are raw binary data, with the filename
2684 // encoding the coordinates.
2685 parse_hgt_filename(lc_name
);
2686 read_bil(zs
, size
, skipbytes
);
2691 if (!ze_data
&& lc_name
.EndsWith(wxT(".bil"))) {
2693 read_bil(zs
, size
, skipbytes
);
2700 if (lc_name
.EndsWith(wxT(".hdr"))) {
2701 size
= parse_hdr(zs
, skipbytes
);
2703 if (!zs
.OpenEntry(*ze_data
)) {
2704 wxMessageBox(wxT("Couldn't read DEM data from .zip file"));
2707 read_bil(zs
, size
, skipbytes
);
2709 } else if (lc_name
.EndsWith(wxT(".prj"))) {
2710 //FIXME: check this matches the datum string we use
2711 //Projection GEOGRAPHIC
2716 //Xshift 0.0000000000
2717 //Yshift 0.0000000000
2730 InvalidateList(LIST_TERRAIN
);
2735 void GfxCore::DrawTerrainTriangle(const Vector3
& a
, const Vector3
& b
, const Vector3
& c
)
2737 Vector3 n
= (b
- a
) * (c
- a
);
2739 Double factor
= dot(n
, light
) * .95 + .05;
2740 SetColour(col_WHITE
, factor
);
2747 void GfxCore::DrawTerrain()
2751 wxBusyCursor hourglass
;
2753 // Draw terrain to twice the extent, or at least 1km.
2754 double r_sqrd
= sqrd(max(m_Parent
->GetExtent().magnitude(), 1000.0));
2755 #define WGS84_DATUM_STRING "+proj=longlat +ellps=WGS84 +datum=WGS84"
2756 static projPJ pj_in
= pj_init_plus(WGS84_DATUM_STRING
);
2759 error(/*Failed to initialise input coordinate system “%s”*/287, WGS84_DATUM_STRING
);
2762 static projPJ pj_out
= pj_init_plus(m_Parent
->m_cs_proj
.c_str());
2765 error(/*Failed to initialise output coordinate system “%s”*/288, (const char *)m_Parent
->m_cs_proj
.c_str());
2771 const Vector3
& off
= m_Parent
->GetOffset();
2772 vector
<Vector3
> prevcol(dem_height
+ 1);
2773 for (size_t x
= 0; x
< dem_width
; ++x
) {
2774 double X_
= (o_x
+ x
* step_x
) * DEG_TO_RAD
;
2776 for (size_t y
= 0; y
< dem_height
; ++y
) {
2777 unsigned short elev
= dem
[x
+ y
* dem_width
];
2778 #ifdef WORDS_BIGENDIAN
2779 const bool MACHINE_BIGENDIAN
= true;
2781 const bool MACHINE_BIGENDIAN
= false;
2783 if (bigendian
!= MACHINE_BIGENDIAN
) {
2784 #if defined __GNUC__ && (__GNUC__ * 100 + __GNUC_MINOR__ >= 408)
2785 elev
= __builtin_bswap16(elev
);
2787 elev
= (elev
>> 8) | (elev
<< 8);
2790 double Z
= (short)elev
;
2792 if (Z
== nodata_value
) {
2793 pt
= Vector3(DBL_MAX
, DBL_MAX
, DBL_MAX
);
2796 double Y
= (o_y
- y
* step_y
) * DEG_TO_RAD
;
2797 pj_transform(pj_in
, pj_out
, 1, 1, &X
, &Y
, &Z
);
2798 pt
= Vector3(X
, Y
, Z
) - off
;
2799 double dist_2
= sqrd(pt
.GetX()) + sqrd(pt
.GetY());
2800 if (dist_2
> r_sqrd
) {
2801 pt
= Vector3(DBL_MAX
, DBL_MAX
, DBL_MAX
);
2804 if (x
> 0 && y
> 0) {
2805 const Vector3
& a
= prevcol
[y
- 1];
2806 const Vector3
& b
= prevcol
[y
];
2807 // If all points are valid, split the quadrilateral into
2808 // triangles along the shorter 3D diagonal, which typically
2812 // prev---a x prev---a
2814 // y | | / | or | \ |
2820 enum { NONE
= 0, P
= 1, Q
= 2, R
= 4, S
= 8, ALL
= P
|Q
|R
|S
};
2822 ((prev
.GetZ() != DBL_MAX
)) |
2823 ((a
.GetZ() != DBL_MAX
) << 1) |
2824 ((b
.GetZ() != DBL_MAX
) << 2) |
2825 ((pt
.GetZ() != DBL_MAX
) << 3);
2826 static const int tris_map
[16] = {
2827 NONE
, // nothing valid
2842 ALL
, // pt, b, a, prev
2844 int tris
= tris_map
[valid
];
2846 // All points valid.
2847 if ((a
- b
).magnitude() < (prev
- pt
).magnitude()) {
2854 DrawTerrainTriangle(a
, prev
, b
);
2856 DrawTerrainTriangle(a
, b
, pt
);
2858 DrawTerrainTriangle(pt
, prev
, b
);
2860 DrawTerrainTriangle(a
, prev
, pt
);
2863 prevcol
[y
].assign(pt
);
2871 void GfxCore::GenerateBlobsDisplayList()
2873 if (!(m_Entrances
|| m_FixedPts
|| m_ExportedPts
||
2874 m_Parent
->GetNumHighlightedPts()))
2878 gla_colour prev_col
= col_BLACK
; // not a colour used for blobs
2879 list
<LabelInfo
*>::const_iterator pos
= m_Parent
->GetLabels();
2881 while (pos
!= m_Parent
->GetLabelsEnd()) {
2882 const LabelInfo
* label
= *pos
++;
2884 // When more than one flag is set on a point:
2885 // search results take priority over entrance highlighting
2886 // which takes priority over fixed point
2887 // highlighting, which in turn takes priority over exported
2888 // point highlighting.
2890 if (!((m_Surface
&& label
->IsSurface()) ||
2891 (m_Legs
&& label
->IsUnderground()) ||
2892 (!label
->IsSurface() && !label
->IsUnderground()))) {
2893 // if this station isn't to be displayed, skip to the next
2894 // (last case is for stns with no legs attached)
2900 if (label
->IsHighLighted()) {
2902 } else if (m_Entrances
&& label
->IsEntrance()) {
2904 } else if (m_FixedPts
&& label
->IsFixedPt()) {
2906 } else if (m_ExportedPts
&& label
->IsExportedPt()) {
2907 col
= col_TURQUOISE
;
2912 // Stations are sorted by blob type, so colour changes are infrequent.
2913 if (col
!= prev_col
) {
2917 DrawBlob(label
->GetX(), label
->GetY(), label
->GetZ());
2922 void GfxCore::DrawIndicators()
2926 drawing_list key_list
= LIST_LIMIT_
;
2927 switch (m_ColourBy
) {
2928 case COLOUR_BY_DEPTH
:
2929 key_list
= LIST_DEPTH_KEY
; break;
2930 case COLOUR_BY_DATE
:
2931 key_list
= LIST_DATE_KEY
; break;
2932 case COLOUR_BY_ERROR
:
2933 key_list
= LIST_ERROR_KEY
; break;
2934 case COLOUR_BY_GRADIENT
:
2935 key_list
= LIST_GRADIENT_KEY
; break;
2936 case COLOUR_BY_LENGTH
:
2937 key_list
= LIST_LENGTH_KEY
; break;
2939 if (key_list
!= LIST_LIMIT_
) {
2940 DrawList2D(key_list
, GetXSize() - KEY_OFFSET_X
,
2941 GetYSize() - KEY_OFFSET_Y
, 0);
2945 // Draw compass or elevation/heading indicators.
2946 if (m_Compass
|| m_Clino
) {
2947 if (!m_Parent
->IsExtendedElevation()) Draw2dIndicators();
2952 DrawList2D(LIST_SCALE_BAR
, 0, 0, 0);
2956 void GfxCore::PlaceVertexWithColour(const Vector3
& v
,
2957 glaTexCoord tex_x
, glaTexCoord tex_y
,
2960 SetColour(col_WHITE
, factor
);
2961 PlaceVertex(v
, tex_x
, tex_y
);
2964 void GfxCore::SetDepthColour(Double z
, Double factor
) {
2965 // Set the drawing colour based on the altitude.
2966 Double z_ext
= m_Parent
->GetDepthExtent();
2968 z
-= m_Parent
->GetDepthMin();
2969 // points arising from tubes may be slightly outside the limits...
2971 if (z
> z_ext
) z
= z_ext
;
2974 SetColour(GetPen(0), factor
);
2978 assert(z_ext
> 0.0);
2979 Double how_far
= z
/ z_ext
;
2980 assert(how_far
>= 0.0);
2981 assert(how_far
<= 1.0);
2983 int band
= int(floor(how_far
* (GetNumColourBands() - 1)));
2984 GLAPen pen1
= GetPen(band
);
2985 if (band
< GetNumColourBands() - 1) {
2986 const GLAPen
& pen2
= GetPen(band
+ 1);
2988 Double interval
= z_ext
/ (GetNumColourBands() - 1);
2989 Double into_band
= z
/ interval
- band
;
2991 // printf("%g z_offset=%g interval=%g band=%d\n", into_band,
2992 // z_offset, interval, band);
2993 // FIXME: why do we need to clamp here? Is it because the walls can
2994 // extend further up/down than the centre-line?
2995 if (into_band
< 0.0) into_band
= 0.0;
2996 if (into_band
> 1.0) into_band
= 1.0;
2997 assert(into_band
>= 0.0);
2998 assert(into_band
<= 1.0);
3000 pen1
.Interpolate(pen2
, into_band
);
3002 SetColour(pen1
, factor
);
3005 void GfxCore::PlaceVertexWithDepthColour(const Vector3
&v
, Double factor
)
3007 SetDepthColour(v
.GetZ(), factor
);
3011 void GfxCore::PlaceVertexWithDepthColour(const Vector3
&v
,
3012 glaTexCoord tex_x
, glaTexCoord tex_y
,
3015 SetDepthColour(v
.GetZ(), factor
);
3016 PlaceVertex(v
, tex_x
, tex_y
);
3019 void GfxCore::SplitLineAcrossBands(int band
, int band2
,
3020 const Vector3
&p
, const Vector3
&q
,
3023 const int step
= (band
< band2
) ? 1 : -1;
3024 for (int i
= band
; i
!= band2
; i
+= step
) {
3025 const Double z
= GetDepthBoundaryBetweenBands(i
, i
+ step
);
3027 // Find the intersection point of the line p -> q
3028 // with the plane parallel to the xy-plane with z-axis intersection z.
3029 assert(q
.GetZ() - p
.GetZ() != 0.0);
3031 const Double t
= (z
- p
.GetZ()) / (q
.GetZ() - p
.GetZ());
3032 // assert(0.0 <= t && t <= 1.0); FIXME: rounding problems!
3034 const Double x
= p
.GetX() + t
* (q
.GetX() - p
.GetX());
3035 const Double y
= p
.GetY() + t
* (q
.GetY() - p
.GetY());
3037 PlaceVertexWithDepthColour(Vector3(x
, y
, z
), factor
);
3041 int GfxCore::GetDepthColour(Double z
) const
3043 // Return the (0-based) depth colour band index for a z-coordinate.
3044 Double z_ext
= m_Parent
->GetDepthExtent();
3045 z
-= m_Parent
->GetDepthMin();
3046 // We seem to get rounding differences causing z to sometimes be slightly
3047 // less than GetDepthMin() here, and it can certainly be true for passage
3048 // tubes, so just clamp the value to 0.
3049 if (z
<= 0) return 0;
3050 // We seem to get rounding differences causing z to sometimes exceed z_ext
3051 // by a small amount here (see: http://trac.survex.com/ticket/26) and it
3052 // can certainly be true for passage tubes, so just clamp the value.
3053 if (z
>= z_ext
) return GetNumColourBands() - 1;
3054 return int(z
/ z_ext
* (GetNumColourBands() - 1));
3057 Double
GfxCore::GetDepthBoundaryBetweenBands(int a
, int b
) const
3059 // Return the z-coordinate of the depth colour boundary between
3060 // two adjacent depth colour bands (specified by 0-based indices).
3062 assert((a
== b
- 1) || (a
== b
+ 1));
3063 if (GetNumColourBands() == 1) return 0;
3065 int band
= (a
> b
) ? a
: b
; // boundary N lies on the bottom of band N.
3066 Double z_ext
= m_Parent
->GetDepthExtent();
3067 return (z_ext
* band
/ (GetNumColourBands() - 1)) + m_Parent
->GetDepthMin();
3070 void GfxCore::AddPolyline(const traverse
& centreline
)
3073 SetColour(col_WHITE
);
3074 vector
<PointInfo
>::const_iterator i
= centreline
.begin();
3077 while (i
!= centreline
.end()) {
3084 void GfxCore::AddPolylineShadow(const traverse
& centreline
)
3087 const double z
= -0.5 * m_Parent
->GetZExtent();
3088 vector
<PointInfo
>::const_iterator i
= centreline
.begin();
3089 PlaceVertex(i
->GetX(), i
->GetY(), z
);
3091 while (i
!= centreline
.end()) {
3092 PlaceVertex(i
->GetX(), i
->GetY(), z
);
3098 void GfxCore::AddPolylineDepth(const traverse
& centreline
)
3101 vector
<PointInfo
>::const_iterator i
, prev_i
;
3102 i
= centreline
.begin();
3103 int band0
= GetDepthColour(i
->GetZ());
3104 PlaceVertexWithDepthColour(*i
);
3107 while (i
!= centreline
.end()) {
3108 int band
= GetDepthColour(i
->GetZ());
3109 if (band
!= band0
) {
3110 SplitLineAcrossBands(band0
, band
, *prev_i
, *i
);
3113 PlaceVertexWithDepthColour(*i
);
3120 void GfxCore::AddQuadrilateral(const Vector3
&a
, const Vector3
&b
,
3121 const Vector3
&c
, const Vector3
&d
)
3123 Vector3 normal
= (a
- c
) * (d
- b
);
3125 Double factor
= dot(normal
, light
) * .3 + .7;
3126 glaTexCoord
w(ceil(((b
- a
).magnitude() + (d
- c
).magnitude()) * .5));
3127 glaTexCoord
h(ceil(((b
- c
).magnitude() + (d
- a
).magnitude()) * .5));
3128 // FIXME: should plot triangles instead to avoid rendering glitches.
3129 BeginQuadrilaterals();
3130 PlaceVertexWithColour(a
, 0, 0, factor
);
3131 PlaceVertexWithColour(b
, w
, 0, factor
);
3132 PlaceVertexWithColour(c
, w
, h
, factor
);
3133 PlaceVertexWithColour(d
, 0, h
, factor
);
3134 EndQuadrilaterals();
3137 void GfxCore::AddQuadrilateralDepth(const Vector3
&a
, const Vector3
&b
,
3138 const Vector3
&c
, const Vector3
&d
)
3140 Vector3 normal
= (a
- c
) * (d
- b
);
3142 Double factor
= dot(normal
, light
) * .3 + .7;
3143 int a_band
, b_band
, c_band
, d_band
;
3144 a_band
= GetDepthColour(a
.GetZ());
3145 a_band
= min(max(a_band
, 0), GetNumColourBands());
3146 b_band
= GetDepthColour(b
.GetZ());
3147 b_band
= min(max(b_band
, 0), GetNumColourBands());
3148 c_band
= GetDepthColour(c
.GetZ());
3149 c_band
= min(max(c_band
, 0), GetNumColourBands());
3150 d_band
= GetDepthColour(d
.GetZ());
3151 d_band
= min(max(d_band
, 0), GetNumColourBands());
3152 // All this splitting is incorrect - we need to make a separate polygon
3153 // for each depth band...
3154 glaTexCoord
w(ceil(((b
- a
).magnitude() + (d
- c
).magnitude()) * .5));
3155 glaTexCoord
h(ceil(((b
- c
).magnitude() + (d
- a
).magnitude()) * .5));
3157 //// PlaceNormal(normal);
3158 PlaceVertexWithDepthColour(a
, 0, 0, factor
);
3159 if (a_band
!= b_band
) {
3160 SplitLineAcrossBands(a_band
, b_band
, a
, b
, factor
);
3162 PlaceVertexWithDepthColour(b
, w
, 0, factor
);
3163 if (b_band
!= c_band
) {
3164 SplitLineAcrossBands(b_band
, c_band
, b
, c
, factor
);
3166 PlaceVertexWithDepthColour(c
, w
, h
, factor
);
3167 if (c_band
!= d_band
) {
3168 SplitLineAcrossBands(c_band
, d_band
, c
, d
, factor
);
3170 PlaceVertexWithDepthColour(d
, 0, h
, factor
);
3171 if (d_band
!= a_band
) {
3172 SplitLineAcrossBands(d_band
, a_band
, d
, a
, factor
);
3177 void GfxCore::SetColourFromDate(int date
, Double factor
)
3179 // Set the drawing colour based on a date.
3183 SetColour(col_WHITE
, factor
);
3187 int date_offset
= date
- m_Parent
->GetDateMin();
3188 if (date_offset
== 0) {
3189 // Earliest date - handle as a special case for the single date case.
3190 SetColour(GetPen(0), factor
);
3194 int date_ext
= m_Parent
->GetDateExtent();
3195 Double how_far
= (Double
)date_offset
/ date_ext
;
3196 assert(how_far
>= 0.0);
3197 assert(how_far
<= 1.0);
3198 SetColourFrom01(how_far
, factor
);
3201 void GfxCore::AddPolylineDate(const traverse
& centreline
)
3204 vector
<PointInfo
>::const_iterator i
, prev_i
;
3205 i
= centreline
.begin();
3206 int date
= i
->GetDate();
3207 SetColourFromDate(date
, 1.0);
3210 while (++i
!= centreline
.end()) {
3211 int newdate
= i
->GetDate();
3212 if (newdate
!= date
) {
3216 SetColourFromDate(date
, 1.0);
3217 PlaceVertex(*prev_i
);
3225 static int static_date_hack
; // FIXME
3227 void GfxCore::AddQuadrilateralDate(const Vector3
&a
, const Vector3
&b
,
3228 const Vector3
&c
, const Vector3
&d
)
3230 Vector3 normal
= (a
- c
) * (d
- b
);
3232 Double factor
= dot(normal
, light
) * .3 + .7;
3233 int w
= int(ceil(((b
- a
).magnitude() + (d
- c
).magnitude()) / 2));
3234 int h
= int(ceil(((b
- c
).magnitude() + (d
- a
).magnitude()) / 2));
3235 // FIXME: should plot triangles instead to avoid rendering glitches.
3236 BeginQuadrilaterals();
3237 //// PlaceNormal(normal);
3238 SetColourFromDate(static_date_hack
, factor
);
3239 PlaceVertex(a
, 0, 0);
3240 PlaceVertex(b
, w
, 0);
3241 PlaceVertex(c
, w
, h
);
3242 PlaceVertex(d
, 0, h
);
3243 EndQuadrilaterals();
3246 static double static_E_hack
; // FIXME
3248 void GfxCore::SetColourFromError(double E
, Double factor
)
3250 // Set the drawing colour based on an error value.
3253 SetColour(col_WHITE
, factor
);
3257 Double how_far
= E
/ MAX_ERROR
;
3258 assert(how_far
>= 0.0);
3259 if (how_far
> 1.0) how_far
= 1.0;
3260 SetColourFrom01(how_far
, factor
);
3263 void GfxCore::AddQuadrilateralError(const Vector3
&a
, const Vector3
&b
,
3264 const Vector3
&c
, const Vector3
&d
)
3266 Vector3 normal
= (a
- c
) * (d
- b
);
3268 Double factor
= dot(normal
, light
) * .3 + .7;
3269 int w
= int(ceil(((b
- a
).magnitude() + (d
- c
).magnitude()) / 2));
3270 int h
= int(ceil(((b
- c
).magnitude() + (d
- a
).magnitude()) / 2));
3271 // FIXME: should plot triangles instead to avoid rendering glitches.
3272 BeginQuadrilaterals();
3273 //// PlaceNormal(normal);
3274 SetColourFromError(static_E_hack
, factor
);
3275 PlaceVertex(a
, 0, 0);
3276 PlaceVertex(b
, w
, 0);
3277 PlaceVertex(c
, w
, h
);
3278 PlaceVertex(d
, 0, h
);
3279 EndQuadrilaterals();
3282 void GfxCore::AddPolylineError(const traverse
& centreline
)
3285 SetColourFromError(centreline
.E
, 1.0);
3286 vector
<PointInfo
>::const_iterator i
;
3287 for(i
= centreline
.begin(); i
!= centreline
.end(); ++i
) {
3293 // gradient is in *radians*.
3294 void GfxCore::SetColourFromGradient(double gradient
, Double factor
)
3296 // Set the drawing colour based on the gradient of the leg.
3298 const Double GRADIENT_MAX
= M_PI_2
;
3299 gradient
= fabs(gradient
);
3300 Double how_far
= gradient
/ GRADIENT_MAX
;
3301 SetColourFrom01(how_far
, factor
);
3304 void GfxCore::AddPolylineGradient(const traverse
& centreline
)
3306 vector
<PointInfo
>::const_iterator i
, prev_i
;
3307 i
= centreline
.begin();
3309 while (++i
!= centreline
.end()) {
3311 SetColourFromGradient((*i
- *prev_i
).gradient(), 1.0);
3312 PlaceVertex(*prev_i
);
3319 static double static_gradient_hack
; // FIXME
3321 void GfxCore::AddQuadrilateralGradient(const Vector3
&a
, const Vector3
&b
,
3322 const Vector3
&c
, const Vector3
&d
)
3324 Vector3 normal
= (a
- c
) * (d
- b
);
3326 Double factor
= dot(normal
, light
) * .3 + .7;
3327 int w
= int(ceil(((b
- a
).magnitude() + (d
- c
).magnitude()) / 2));
3328 int h
= int(ceil(((b
- c
).magnitude() + (d
- a
).magnitude()) / 2));
3329 // FIXME: should plot triangles instead to avoid rendering glitches.
3330 BeginQuadrilaterals();
3331 //// PlaceNormal(normal);
3332 SetColourFromGradient(static_gradient_hack
, factor
);
3333 PlaceVertex(a
, 0, 0);
3334 PlaceVertex(b
, w
, 0);
3335 PlaceVertex(c
, w
, h
);
3336 PlaceVertex(d
, 0, h
);
3337 EndQuadrilaterals();
3340 void GfxCore::SetColourFromLength(double length
, Double factor
)
3342 // Set the drawing colour based on log(length_of_leg).
3344 Double log_len
= log10(length
);
3345 Double how_far
= log_len
/ LOG_LEN_MAX
;
3346 how_far
= max(how_far
, 0.0);
3347 how_far
= min(how_far
, 1.0);
3348 SetColourFrom01(how_far
, factor
);
3351 void GfxCore::SetColourFrom01(double how_far
, Double factor
)
3354 double into_band
= modf(how_far
* (GetNumColourBands() - 1), &b
);
3356 GLAPen pen1
= GetPen(band
);
3357 // With 24bit colour, interpolating by less than this can have no effect.
3358 if (into_band
>= 1.0 / 512.0) {
3359 const GLAPen
& pen2
= GetPen(band
+ 1);
3360 pen1
.Interpolate(pen2
, into_band
);
3362 SetColour(pen1
, factor
);
3365 void GfxCore::AddPolylineLength(const traverse
& centreline
)
3367 vector
<PointInfo
>::const_iterator i
, prev_i
;
3368 i
= centreline
.begin();
3370 while (++i
!= centreline
.end()) {
3372 SetColourFromLength((*i
- *prev_i
).magnitude(), 1.0);
3373 PlaceVertex(*prev_i
);
3380 static double static_length_hack
; // FIXME
3382 void GfxCore::AddQuadrilateralLength(const Vector3
&a
, const Vector3
&b
,
3383 const Vector3
&c
, const Vector3
&d
)
3385 Vector3 normal
= (a
- c
) * (d
- b
);
3387 Double factor
= dot(normal
, light
) * .3 + .7;
3388 int w
= int(ceil(((b
- a
).magnitude() + (d
- c
).magnitude()) / 2));
3389 int h
= int(ceil(((b
- c
).magnitude() + (d
- a
).magnitude()) / 2));
3390 // FIXME: should plot triangles instead to avoid rendering glitches.
3391 BeginQuadrilaterals();
3392 //// PlaceNormal(normal);
3393 SetColourFromLength(static_length_hack
, factor
);
3394 PlaceVertex(a
, 0, 0);
3395 PlaceVertex(b
, w
, 0);
3396 PlaceVertex(c
, w
, h
);
3397 PlaceVertex(d
, 0, h
);
3398 EndQuadrilaterals();
3402 GfxCore::SkinPassage(vector
<XSect
> & centreline
, bool draw
)
3404 assert(centreline
.size() > 1);
3407 Vector3
last_right(1.0, 0.0, 0.0);
3409 // FIXME: it's not simple to set the colour of a tube based on error...
3410 // static_E_hack = something...
3411 vector
<XSect
>::iterator i
= centreline
.begin();
3412 vector
<XSect
>::size_type segment
= 0;
3413 while (i
!= centreline
.end()) {
3414 // get the coordinates of this vertex
3415 XSect
& pt_v
= *i
++;
3417 bool cover_end
= false;
3421 const Vector3
up_v(0.0, 0.0, 1.0);
3424 assert(i
!= centreline
.end());
3427 // get the coordinates of the next vertex
3428 const XSect
& next_pt_v
= *i
;
3430 // calculate vector from this pt to the next one
3431 Vector3 leg_v
= next_pt_v
- pt_v
;
3433 // obtain a vector in the LRUD plane
3434 right
= leg_v
* up_v
;
3435 if (right
.magnitude() == 0) {
3437 // Obtain a second vector in the LRUD plane,
3438 // perpendicular to the first.
3439 //up = right * leg_v;
3447 static_date_hack
= next_pt_v
.GetDate();
3448 } else if (segment
+ 1 == centreline
.size()) {
3451 // Calculate vector from the previous pt to this one.
3452 Vector3 leg_v
= pt_v
- prev_pt_v
;
3454 // Obtain a horizontal vector in the LRUD plane.
3455 right
= leg_v
* up_v
;
3456 if (right
.magnitude() == 0) {
3457 right
= Vector3(last_right
.GetX(), last_right
.GetY(), 0.0);
3458 // Obtain a second vector in the LRUD plane,
3459 // perpendicular to the first.
3460 //up = right * leg_v;
3468 static_date_hack
= pt_v
.GetDate();
3470 assert(i
!= centreline
.end());
3471 // Intermediate segment.
3473 // Get the coordinates of the next vertex.
3474 const XSect
& next_pt_v
= *i
;
3476 // Calculate vectors from this vertex to the
3477 // next vertex, and from the previous vertex to
3479 Vector3 leg1_v
= pt_v
- prev_pt_v
;
3480 Vector3 leg2_v
= next_pt_v
- pt_v
;
3482 // Obtain horizontal vectors perpendicular to
3483 // both legs, then normalise and average to get
3484 // a horizontal bisector.
3485 Vector3 r1
= leg1_v
* up_v
;
3486 Vector3 r2
= leg2_v
* up_v
;
3490 if (right
.magnitude() == 0) {
3491 // This is the "mid-pitch" case...
3494 if (r1
.magnitude() == 0) {
3497 // Rotate pitch section to minimise the
3498 // "tortional stress" - FIXME: use
3499 // triangles instead of rectangles?
3503 // Scale to unit vectors in the LRUD plane.
3506 Vector3 vec
= up
- right
;
3507 for (int orient
= 0; orient
<= 3; ++orient
) {
3508 Vector3 tmp
= U
[orient
] - prev_pt_v
;
3510 Double dotp
= dot(vec
, tmp
);
3511 if (dotp
> maxdotp
) {
3521 U
[2] = U
[shift
^ 2];
3522 U
[shift
^ 2] = temp
;
3529 // Check that the above code actually permuted
3530 // the vertices correctly.
3533 for (int j
= 0; j
<= 3; ++j
) {
3534 Vector3 tmp
= U
[j
] - prev_pt_v
;
3536 Double dotp
= dot(vec
, tmp
);
3537 if (dotp
> maxdotp
) {
3538 maxdotp
= dotp
+ 1e-6; // Add small tolerance to stop 45 degree offset cases being flagged...
3543 printf("New shift = %d!\n", shift
);
3546 for (int j
= 0; j
<= 3; ++j
) {
3547 Vector3 tmp
= U
[j
] - prev_pt_v
;
3549 Double dotp
= dot(vec
, tmp
);
3550 printf(" %d : %.8f\n", j
, dotp
);
3558 static_date_hack
= pt_v
.GetDate();
3561 // Scale to unit vectors in the LRUD plane.
3565 Double l
= fabs(pt_v
.GetL());
3566 Double r
= fabs(pt_v
.GetR());
3567 Double u
= fabs(pt_v
.GetU());
3568 Double d
= fabs(pt_v
.GetD());
3570 // Produce coordinates of the corners of the LRUD "plane".
3572 v
[0] = pt_v
- right
* l
+ up
* u
;
3573 v
[1] = pt_v
+ right
* r
+ up
* u
;
3574 v
[2] = pt_v
+ right
* r
- up
* d
;
3575 v
[3] = pt_v
- right
* l
- up
* d
;
3578 const Vector3
& delta
= pt_v
- prev_pt_v
;
3579 static_length_hack
= delta
.magnitude();
3580 static_gradient_hack
= delta
.gradient();
3582 (this->*AddQuad
)(v
[0], v
[1], U
[1], U
[0]);
3583 (this->*AddQuad
)(v
[2], v
[3], U
[3], U
[2]);
3584 (this->*AddQuad
)(v
[1], v
[2], U
[2], U
[1]);
3585 (this->*AddQuad
)(v
[3], v
[0], U
[0], U
[3]);
3590 (this->*AddQuad
)(v
[0], v
[1], v
[2], v
[3]);
3592 (this->*AddQuad
)(v
[3], v
[2], v
[1], v
[0]);
3603 pt_v
.set_right_bearing(deg(atan2(right
.GetY(), right
.GetX())));
3609 void GfxCore::FullScreenMode()
3611 m_Parent
->ViewFullScreen();
3614 bool GfxCore::IsFullScreen() const
3616 return m_Parent
->IsFullScreen();
3619 bool GfxCore::FullScreenModeShowingMenus() const
3621 return m_Parent
->FullScreenModeShowingMenus();
3624 void GfxCore::FullScreenModeShowMenus(bool show
)
3626 m_Parent
->FullScreenModeShowMenus(show
);
3630 GfxCore::MoveViewer(double forward
, double up
, double right
)
3632 double cT
= cos(rad(m_TiltAngle
));
3633 double sT
= sin(rad(m_TiltAngle
));
3634 double cP
= cos(rad(m_PanAngle
));
3635 double sP
= sin(rad(m_PanAngle
));
3636 Vector3
v_forward(cT
* sP
, cT
* cP
, sT
);
3637 Vector3
v_up(sT
* sP
, sT
* cP
, -cT
);
3638 Vector3
v_right(-cP
, sP
, 0);
3639 assert(fabs(dot(v_forward
, v_up
)) < 1e-6);
3640 assert(fabs(dot(v_forward
, v_right
)) < 1e-6);
3641 assert(fabs(dot(v_right
, v_up
)) < 1e-6);
3642 Vector3 move
= v_forward
* forward
+ v_up
* up
+ v_right
* right
;
3643 AddTranslation(-move
);
3644 // Show current position.
3645 m_Parent
->SetCoords(m_Parent
->GetOffset() - GetTranslation());
3649 PresentationMark
GfxCore::GetView() const
3651 return PresentationMark(GetTranslation() + m_Parent
->GetOffset(),
3652 m_PanAngle
, -m_TiltAngle
, m_Scale
);
3655 void GfxCore::SetView(const PresentationMark
& p
)
3658 SetTranslation(p
- m_Parent
->GetOffset());
3659 m_PanAngle
= p
.angle
;
3660 m_TiltAngle
= -p
.tilt_angle
; // FIXME: nasty reversed sense (and above)
3661 SetRotation(m_PanAngle
, m_TiltAngle
);
3666 void GfxCore::PlayPres(double speed
, bool change_speed
) {
3667 if (!change_speed
|| presentation_mode
== 0) {
3669 presentation_mode
= 0;
3672 presentation_mode
= PLAYING
;
3673 next_mark
= m_Parent
->GetPresMark(MARK_FIRST
);
3675 next_mark_time
= 0; // There already!
3676 this_mark_total
= 0;
3677 pres_reverse
= (speed
< 0);
3680 if (change_speed
) pres_speed
= speed
;
3683 bool new_pres_reverse
= (speed
< 0);
3684 if (new_pres_reverse
!= pres_reverse
) {
3685 pres_reverse
= new_pres_reverse
;
3687 next_mark
= m_Parent
->GetPresMark(MARK_PREV
);
3689 next_mark
= m_Parent
->GetPresMark(MARK_NEXT
);
3691 swap(this_mark_total
, next_mark_time
);
3696 void GfxCore::SetColourBy(int colour_by
) {
3697 m_ColourBy
= colour_by
;
3698 switch (colour_by
) {
3699 case COLOUR_BY_DEPTH
:
3700 AddQuad
= &GfxCore::AddQuadrilateralDepth
;
3701 AddPoly
= &GfxCore::AddPolylineDepth
;
3703 case COLOUR_BY_DATE
:
3704 AddQuad
= &GfxCore::AddQuadrilateralDate
;
3705 AddPoly
= &GfxCore::AddPolylineDate
;
3707 case COLOUR_BY_ERROR
:
3708 AddQuad
= &GfxCore::AddQuadrilateralError
;
3709 AddPoly
= &GfxCore::AddPolylineError
;
3711 case COLOUR_BY_GRADIENT
:
3712 AddQuad
= &GfxCore::AddQuadrilateralGradient
;
3713 AddPoly
= &GfxCore::AddPolylineGradient
;
3715 case COLOUR_BY_LENGTH
:
3716 AddQuad
= &GfxCore::AddQuadrilateralLength
;
3717 AddPoly
= &GfxCore::AddPolylineLength
;
3719 default: // case COLOUR_BY_NONE:
3720 AddQuad
= &GfxCore::AddQuadrilateral
;
3721 AddPoly
= &GfxCore::AddPolyline
;
3725 InvalidateList(LIST_UNDERGROUND_LEGS
);
3726 InvalidateList(LIST_SURFACE_LEGS
);
3727 InvalidateList(LIST_TUBES
);
3732 bool GfxCore::ExportMovie(const wxString
& fnm
)
3734 FILE* fh
= wxFopen(fnm
.fn_str(), wxT("wb"));
3736 wxGetApp().ReportError(wxString::Format(wmsg(/*Failed to open output file “%s”*/47), fnm
.c_str()));
3741 wxFileName::SplitPath(fnm
, NULL
, NULL
, NULL
, &ext
, wxPATH_NATIVE
);
3745 GetSize(&width
, &height
);
3746 // Round up to next multiple of 2 (required by ffmpeg).
3747 width
+= (width
& 1);
3748 height
+= (height
& 1);
3750 movie
= new MovieMaker();
3752 // movie takes ownership of fh.
3753 if (!movie
->Open(fh
, ext
.utf8_str(), width
, height
)) {
3754 wxGetApp().ReportError(wxString(movie
->get_error_string(), wxConvUTF8
));
3765 GfxCore::OnPrint(const wxString
&filename
, const wxString
&title
,
3766 const wxString
&datestamp
, time_t datestamp_numeric
,
3767 const wxString
&cs_proj
,
3768 bool close_after_print
)
3771 p
= new svxPrintDlg(m_Parent
, filename
, title
, cs_proj
,
3772 datestamp
, datestamp_numeric
,
3773 m_PanAngle
, m_TiltAngle
,
3774 m_Names
, m_Crosses
, m_Legs
, m_Surface
, m_Splays
,
3775 m_Tubes
, m_Entrances
, m_FixedPts
, m_ExportedPts
,
3776 true, close_after_print
);
3781 GfxCore::OnExport(const wxString
&filename
, const wxString
&title
,
3782 const wxString
&datestamp
, time_t datestamp_numeric
,
3783 const wxString
&cs_proj
)
3785 // Fill in "right_bearing" for each cross-section.
3786 list
<vector
<XSect
> >::iterator trav
= m_Parent
->tubes_begin();
3787 list
<vector
<XSect
> >::iterator tend
= m_Parent
->tubes_end();
3788 while (trav
!= tend
) {
3789 SkinPassage(*trav
, false);
3794 p
= new svxPrintDlg(m_Parent
, filename
, title
, cs_proj
,
3795 datestamp
, datestamp_numeric
,
3796 m_PanAngle
, m_TiltAngle
,
3797 m_Names
, m_Crosses
, m_Legs
, m_Surface
, m_Splays
,
3798 m_Tubes
, m_Entrances
, m_FixedPts
, m_ExportedPts
,
3804 make_cursor(const unsigned char * bits
, const unsigned char * mask
,
3807 #if defined __WXMSW__ || defined __WXMAC__
3809 // The default Mac cursor is black with a white edge, so
3810 // invert our custom cursors to match.
3812 for (int i
= 0; i
< 128; ++i
)
3813 b
[i
] = bits
[i
] ^ 0xff;
3815 const char * b
= reinterpret_cast<const char *>(bits
);
3817 wxBitmap
cursor_bitmap(b
, 32, 32);
3818 wxBitmap
mask_bitmap(reinterpret_cast<const char *>(mask
), 32, 32);
3819 cursor_bitmap
.SetMask(new wxMask(mask_bitmap
, *wxWHITE
));
3820 wxImage cursor_image
= cursor_bitmap
.ConvertToImage();
3821 cursor_image
.SetOption(wxIMAGE_OPTION_CUR_HOTSPOT_X
, hotx
);
3822 cursor_image
.SetOption(wxIMAGE_OPTION_CUR_HOTSPOT_Y
, hoty
);
3823 return wxCursor(cursor_image
);
3825 return wxCursor((const char *)bits
, 32, 32, hotx
, hoty
,
3826 (const char *)mask
, wxBLACK
, wxWHITE
);
3833 #include "handmask.xbm"
3836 #include "brotate.xbm"
3838 #include "brotatemask.xbm"
3841 #include "vrotate.xbm"
3843 #include "vrotatemask.xbm"
3846 #include "rotate.xbm"
3848 #include "rotatemask.xbm"
3851 #include "rotatezoom.xbm"
3853 #include "rotatezoommask.xbm"
3856 GfxCore::UpdateCursor(GfxCore::cursor new_cursor
)
3858 // Check if we're already showing that cursor.
3859 if (current_cursor
== new_cursor
) return;
3861 current_cursor
= new_cursor
;
3862 switch (current_cursor
) {
3863 case GfxCore::CURSOR_DEFAULT
:
3864 GLACanvas::SetCursor(wxNullCursor
);
3866 case GfxCore::CURSOR_POINTING_HAND
:
3867 GLACanvas::SetCursor(wxCursor(wxCURSOR_HAND
));
3869 case GfxCore::CURSOR_DRAGGING_HAND
:
3870 GLACanvas::SetCursor(make_cursor(hand_bits
, handmask_bits
, 12, 18));
3872 case GfxCore::CURSOR_HORIZONTAL_RESIZE
:
3873 GLACanvas::SetCursor(wxCursor(wxCURSOR_SIZEWE
));
3875 case GfxCore::CURSOR_ROTATE_HORIZONTALLY
:
3876 GLACanvas::SetCursor(make_cursor(rotate_bits
, rotatemask_bits
, 15, 15));
3878 case GfxCore::CURSOR_ROTATE_VERTICALLY
:
3879 GLACanvas::SetCursor(make_cursor(vrotate_bits
, vrotatemask_bits
, 15, 15));
3881 case GfxCore::CURSOR_ROTATE_EITHER_WAY
:
3882 GLACanvas::SetCursor(make_cursor(brotate_bits
, brotatemask_bits
, 15, 15));
3884 case GfxCore::CURSOR_ZOOM
:
3885 GLACanvas::SetCursor(wxCursor(wxCURSOR_MAGNIFIER
));
3887 case GfxCore::CURSOR_ZOOM_ROTATE
:
3888 GLACanvas::SetCursor(make_cursor(rotatezoom_bits
, rotatezoommask_bits
, 15, 15));
3893 bool GfxCore::MeasuringLineActive() const
3895 if (Animating()) return false;
3896 return HereIsReal() || m_there
;
3899 bool GfxCore::HandleRClick(wxPoint point
)
3901 if (PointWithinCompass(point
)) {
3904 /* TRANSLATORS: View *looking* North */
3905 menu
.Append(menu_ORIENT_MOVE_NORTH
, wmsg(/*View &North*/240));
3906 /* TRANSLATORS: View *looking* East */
3907 menu
.Append(menu_ORIENT_MOVE_EAST
, wmsg(/*View &East*/241));
3908 /* TRANSLATORS: View *looking* South */
3909 menu
.Append(menu_ORIENT_MOVE_SOUTH
, wmsg(/*View &South*/242));
3910 /* TRANSLATORS: View *looking* West */
3911 menu
.Append(menu_ORIENT_MOVE_WEST
, wmsg(/*View &West*/243));
3912 menu
.AppendSeparator();
3913 /* TRANSLATORS: Menu item which turns off the "north arrow" in aven. */
3914 menu
.AppendCheckItem(menu_IND_COMPASS
, wmsg(/*&Hide Compass*/387));
3915 /* TRANSLATORS: tickable menu item in View menu.
3917 * Degrees are the angular measurement where there are 360 in a full
3919 menu
.AppendCheckItem(menu_CTL_DEGREES
, wmsg(/*&Degrees*/343));
3920 menu
.Connect(wxEVT_COMMAND_MENU_SELECTED
, (wxObjectEventFunction
)&wxEvtHandler::ProcessEvent
, NULL
, m_Parent
->GetEventHandler());
3925 if (PointWithinClino(point
)) {
3928 menu
.Append(menu_ORIENT_PLAN
, wmsg(/*&Plan View*/248));
3929 menu
.Append(menu_ORIENT_ELEVATION
, wmsg(/*Ele&vation*/249));
3930 menu
.AppendSeparator();
3931 /* TRANSLATORS: Menu item which turns off the tilt indicator in aven. */
3932 menu
.AppendCheckItem(menu_IND_CLINO
, wmsg(/*&Hide Clino*/384));
3933 /* TRANSLATORS: tickable menu item in View menu.
3935 * Degrees are the angular measurement where there are 360 in a full
3937 menu
.AppendCheckItem(menu_CTL_DEGREES
, wmsg(/*&Degrees*/343));
3938 /* TRANSLATORS: tickable menu item in View menu.
3940 * Show the tilt of the survey as a percentage gradient (100% = 45
3941 * degrees = 50 grad). */
3942 menu
.AppendCheckItem(menu_CTL_PERCENT
, wmsg(/*&Percent*/430));
3943 menu
.Connect(wxEVT_COMMAND_MENU_SELECTED
, (wxObjectEventFunction
)&wxEvtHandler::ProcessEvent
, NULL
, m_Parent
->GetEventHandler());
3948 if (PointWithinScaleBar(point
)) {
3951 /* TRANSLATORS: Menu item which turns off the scale bar in aven. */
3952 menu
.AppendCheckItem(menu_IND_SCALE_BAR
, wmsg(/*&Hide scale bar*/385));
3953 /* TRANSLATORS: tickable menu item in View menu.
3955 * "Metric" here means metres, km, etc (rather than feet, miles, etc)
3957 menu
.AppendCheckItem(menu_CTL_METRIC
, wmsg(/*&Metric*/342));
3958 menu
.Connect(wxEVT_COMMAND_MENU_SELECTED
, (wxObjectEventFunction
)&wxEvtHandler::ProcessEvent
, NULL
, m_Parent
->GetEventHandler());
3963 if (PointWithinColourKey(point
)) {
3966 menu
.AppendCheckItem(menu_COLOUR_BY_DEPTH
, wmsg(/*Colour by &Depth*/292));
3967 menu
.AppendCheckItem(menu_COLOUR_BY_DATE
, wmsg(/*Colour by D&ate*/293));
3968 menu
.AppendCheckItem(menu_COLOUR_BY_ERROR
, wmsg(/*Colour by &Error*/289));
3969 menu
.AppendCheckItem(menu_COLOUR_BY_GRADIENT
, wmsg(/*Colour by &Gradient*/85));
3970 menu
.AppendCheckItem(menu_COLOUR_BY_LENGTH
, wmsg(/*Colour by &Length*/82));
3971 menu
.AppendSeparator();
3972 /* TRANSLATORS: Menu item which turns off the colour key.
3973 * The "Colour Key" is the thing in aven showing which colour
3974 * corresponds to which depth, date, survey closure error, etc. */
3975 menu
.AppendCheckItem(menu_IND_COLOUR_KEY
, wmsg(/*&Hide colour key*/386));
3976 if (m_ColourBy
== COLOUR_BY_DEPTH
|| m_ColourBy
== COLOUR_BY_LENGTH
)
3977 menu
.AppendCheckItem(menu_CTL_METRIC
, wmsg(/*&Metric*/342));
3978 else if (m_ColourBy
== COLOUR_BY_GRADIENT
)
3979 menu
.AppendCheckItem(menu_CTL_DEGREES
, wmsg(/*&Degrees*/343));
3980 menu
.Connect(wxEVT_COMMAND_MENU_SELECTED
, (wxObjectEventFunction
)&wxEvtHandler::ProcessEvent
, NULL
, m_Parent
->GetEventHandler());
3988 void GfxCore::SetZoomBox(wxPoint p1
, wxPoint p2
, bool centred
, bool aspect
)
3991 p1
.x
= p2
.x
+ (p1
.x
- p2
.x
) * 2;
3992 p1
.y
= p2
.y
+ (p1
.y
- p2
.y
) * 2;
3995 #if 0 // FIXME: This needs more work.
3996 int sx
= GetXSize();
3997 int sy
= GetYSize();
3998 int dx
= p1
.x
- p2
.x
;
3999 int dy
= p1
.y
- p2
.y
;
4000 int dy_new
= dx
* sy
/ sx
;
4001 if (abs(dy_new
) >= abs(dy
)) {
4002 p1
.y
+= (dy_new
- dy
) / 2;
4003 p2
.y
-= (dy_new
- dy
) / 2;
4005 int dx_new
= dy
* sx
/ sy
;
4006 p1
.x
+= (dx_new
- dx
) / 2;
4007 p2
.x
-= (dx_new
- dx
) / 2;
4011 zoombox
.set(p1
, p2
);
4015 void GfxCore::ZoomBoxGo()
4017 if (!zoombox
.active()) return;
4019 int width
= GetXSize();
4020 int height
= GetYSize();
4022 TranslateCave(-0.5 * (zoombox
.x1
+ zoombox
.x2
- width
),
4023 -0.5 * (zoombox
.y1
+ zoombox
.y2
- height
));
4024 int box_w
= abs(zoombox
.x1
- zoombox
.x2
);
4025 int box_h
= abs(zoombox
.y1
- zoombox
.y2
);
4027 double factor
= min(double(width
) / box_w
, double(height
) / box_h
);
4031 SetScale(GetScale() * factor
);