← Back to branch summary

~ubuntu-branches/ubuntu/wily/ginkgocadx/wily-proposed

« back to all changes in this revision

Viewing changes to src/cadxcore/main/tools/herramientaelevacion.cpp

  • Committer: Bazaar Package Importer
  • Author(s): Andreas Tille
  • Date: 2011-05-02 08:09:26 UTC
  • Revision ID: james.westby@ubuntu.com-20110502080926-bql5wep49c7hg91t
Tags: upstream-2.4.1.1
Import upstream version 2.4.1.1

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/cadxcore/main/tools/herramientaelevacion.cpp
 
1
/*
 
2
 *  
 
3
 *  $Id: herramientaelevacion.cpp 3526 2011-03-16 19:56:19Z carlos $
 
4
 *  Ginkgo CADx Project
 
5
 *
 
6
 *  Copyright 2008-10 MetaEmotion S.L. All rights reserved.
 
7
 *  http://ginkgo-cadx.com
 
8
 *
 
9
 *  This file is licensed under LGPL v3 license.
 
10
 *  See License.txt for details
 
11
 *
 
12
 *
 
13
 */
 
14
//#define _GINKGO_TRACE
 
15
#include <wx/aui/aui.h>
 
16
#include <wx/stattext.h>
 
17
#include <wx/slider.h>
 
18
 
 
19
#include <api/globals.h>
 
20
#include <api/iwidgetsmanager.h>
 
21
#include "herramientaelevacion.h"
 
22
#include <resources/ginkgoresourcemanager.h>
 
23
#include <api/inotificadoresherramientas.h>
 
24
#include <main/entorno.h>
 
25
#include <api/internacionalizacion.h>
 
26
 
 
27
#ifdef __DEPRECATED
 
28
#undef __DEPRECATED
 
29
#endif
 
30
#include <vtk/vtkginkgoimageviewer.h>
 
31
#include <vtkImageData.h>
 
32
#include <vtkPointData.h>
 
33
 
 
34
//#include <AVL.h>
 
35
 
 
36
#define ELEVAR_VALORACION 1351
 
37
#define DISMINUIR_VALORACION 1352
 
38
 
 
39
 
 
40
namespace GNC {
 
41
        namespace GUI {
 
42
                class HerramientaOpcionesElevacionGUI : public AUI_NAMESPACE wxAuiToolBar {
 
43
                public:
 
44
                        HerramientaOpcionesElevacionGUI(wxWindow* pParent, GNC::HerramientaElevacion* pHerramienta): AUI_NAMESPACE wxAuiToolBar(pParent,wxID_ANY, wxDefaultPosition, wxDefaultSize)
 
45
                        {
 
46
                                m_pHerramienta = pHerramienta;
 
47
 
 
48
                                SetToolBitmapSize( wxSize( 16,16 ) );
 
49
                                AddTool( DISMINUIR_VALORACION, _("Decrease"), GinkgoResourcesManager::BarraElevacion::GetIcoDisminuirValoracion(), _("Decrease value"), wxITEM_CHECK);
 
50
                                AddTool( ELEVAR_VALORACION, _("Increase"), GinkgoResourcesManager::BarraElevacion::GetIcoAumentarValoracion(), _("Increase value"), wxITEM_CHECK );
 
51
                                ToggleTool(ELEVAR_VALORACION,true);
 
52
 
 
53
                                AddSeparator();
 
54
 
 
55
 
 
56
                                wxStaticText* m_staticText4 = new wxStaticText( this, wxID_ANY, _("Radious"), wxDefaultPosition, wxSize(-1,16), 0 );
 
57
                                AddControl(m_staticText4 );
 
58
                                m_pSliderRadio = new wxSlider( this, wxID_ANY, 15, 1, 100, wxDefaultPosition, wxSize(-1,16), wxSL_HORIZONTAL );
 
59
                                m_pSliderRadio->SetToolTip(_("Radious"));
 
60
                                AddControl(m_pSliderRadio);
 
61
                                AddSeparator();
 
62
 
 
63
                                m_pLabelFactor = new wxStaticText( this, wxID_ANY, _("Factor (0.50)"), wxDefaultPosition, wxSize(-1,16), 0 );
 
64
                                AddControl(m_pLabelFactor );
 
65
                                m_pSliderFactor = new wxSlider( this, wxID_ANY, 50,0, 100, wxDefaultPosition, wxSize(-1,16), wxSL_HORIZONTAL );
 
66
                                m_pSliderFactor->SetToolTip(_("Factor"));
 
67
                                AddControl(m_pSliderFactor);
 
68
 
 
69
                                Realize();
 
70
                                Layout();
 
71
 
 
72
                                // Connect Events
 
73
                                this->Connect( ELEVAR_VALORACION, wxEVT_COMMAND_TOOL_CLICKED, wxCommandEventHandler( HerramientaOpcionesElevacionGUI::OnBElevarClick ) );
 
74
                                this->Connect( DISMINUIR_VALORACION, wxEVT_COMMAND_TOOL_CLICKED, wxCommandEventHandler( HerramientaOpcionesElevacionGUI::OnBDisminuirClick ) );
 
75
 
 
76
                                m_pSliderRadio->Connect( wxEVT_SCROLL_TOP, wxScrollEventHandler( HerramientaOpcionesElevacionGUI::OnRadioScroll ), NULL, this );
 
77
                                m_pSliderRadio->Connect( wxEVT_SCROLL_BOTTOM, wxScrollEventHandler( HerramientaOpcionesElevacionGUI::OnRadioScroll ), NULL, this );
 
78
                                m_pSliderRadio->Connect( wxEVT_SCROLL_LINEUP, wxScrollEventHandler( HerramientaOpcionesElevacionGUI::OnRadioScroll ), NULL, this );
 
79
                                m_pSliderRadio->Connect( wxEVT_SCROLL_LINEDOWN, wxScrollEventHandler( HerramientaOpcionesElevacionGUI::OnRadioScroll ), NULL, this );
 
80
                                m_pSliderRadio->Connect( wxEVT_SCROLL_PAGEUP, wxScrollEventHandler( HerramientaOpcionesElevacionGUI::OnRadioScroll ), NULL, this );
 
81
                                m_pSliderRadio->Connect( wxEVT_SCROLL_PAGEDOWN, wxScrollEventHandler( HerramientaOpcionesElevacionGUI::OnRadioScroll ), NULL, this );
 
82
                                m_pSliderRadio->Connect( wxEVT_SCROLL_THUMBTRACK, wxScrollEventHandler( HerramientaOpcionesElevacionGUI::OnRadioScroll ), NULL, this );
 
83
                                m_pSliderRadio->Connect( wxEVT_SCROLL_THUMBRELEASE, wxScrollEventHandler( HerramientaOpcionesElevacionGUI::OnRadioScroll ), NULL, this );
 
84
                                m_pSliderRadio->Connect( wxEVT_SCROLL_CHANGED, wxScrollEventHandler( HerramientaOpcionesElevacionGUI::OnRadioScroll ), NULL, this );
 
85
 
 
86
                                m_pSliderFactor->Connect( wxEVT_SCROLL_TOP, wxScrollEventHandler( HerramientaOpcionesElevacionGUI::OnFactorScroll ), NULL, this );
 
87
                                m_pSliderFactor->Connect( wxEVT_SCROLL_BOTTOM, wxScrollEventHandler( HerramientaOpcionesElevacionGUI::OnFactorScroll ), NULL, this );
 
88
                                m_pSliderFactor->Connect( wxEVT_SCROLL_LINEUP, wxScrollEventHandler( HerramientaOpcionesElevacionGUI::OnFactorScroll ), NULL, this );
 
89
                                m_pSliderFactor->Connect( wxEVT_SCROLL_LINEDOWN, wxScrollEventHandler( HerramientaOpcionesElevacionGUI::OnFactorScroll ), NULL, this );
 
90
                                m_pSliderFactor->Connect( wxEVT_SCROLL_PAGEUP, wxScrollEventHandler( HerramientaOpcionesElevacionGUI::OnFactorScroll ), NULL, this );
 
91
                                m_pSliderFactor->Connect( wxEVT_SCROLL_PAGEDOWN, wxScrollEventHandler( HerramientaOpcionesElevacionGUI::OnFactorScroll ), NULL, this );
 
92
                                m_pSliderFactor->Connect( wxEVT_SCROLL_THUMBTRACK, wxScrollEventHandler( HerramientaOpcionesElevacionGUI::OnFactorScroll ), NULL, this );
 
93
                                m_pSliderFactor->Connect( wxEVT_SCROLL_THUMBRELEASE, wxScrollEventHandler( HerramientaOpcionesElevacionGUI::OnFactorScroll ), NULL, this );
 
94
                                m_pSliderFactor->Connect( wxEVT_SCROLL_CHANGED, wxScrollEventHandler( HerramientaOpcionesElevacionGUI::OnFactorScroll ), NULL, this );
 
95
                        }
 
96
 
 
97
                        ~HerramientaOpcionesElevacionGUI(){
 
98
                                // Disconnect Events
 
99
                                this->Disconnect( ELEVAR_VALORACION, wxEVT_COMMAND_TOOL_CLICKED, wxCommandEventHandler( HerramientaOpcionesElevacionGUI::OnBElevarClick ) );
 
100
                                this->Disconnect( DISMINUIR_VALORACION, wxEVT_COMMAND_TOOL_CLICKED, wxCommandEventHandler( HerramientaOpcionesElevacionGUI::OnBDisminuirClick ) );
 
101
 
 
102
                                m_pSliderRadio->Disconnect( wxEVT_SCROLL_TOP, wxScrollEventHandler( HerramientaOpcionesElevacionGUI::OnRadioScroll ), NULL, this );
 
103
                                m_pSliderRadio->Disconnect( wxEVT_SCROLL_BOTTOM, wxScrollEventHandler( HerramientaOpcionesElevacionGUI::OnRadioScroll ), NULL, this );
 
104
                                m_pSliderRadio->Disconnect( wxEVT_SCROLL_LINEUP, wxScrollEventHandler( HerramientaOpcionesElevacionGUI::OnRadioScroll ), NULL, this );
 
105
                                m_pSliderRadio->Disconnect( wxEVT_SCROLL_LINEDOWN, wxScrollEventHandler( HerramientaOpcionesElevacionGUI::OnRadioScroll ), NULL, this );
 
106
                                m_pSliderRadio->Disconnect( wxEVT_SCROLL_PAGEUP, wxScrollEventHandler( HerramientaOpcionesElevacionGUI::OnRadioScroll ), NULL, this );
 
107
                                m_pSliderRadio->Disconnect( wxEVT_SCROLL_PAGEDOWN, wxScrollEventHandler( HerramientaOpcionesElevacionGUI::OnRadioScroll ), NULL, this );
 
108
                                m_pSliderRadio->Disconnect( wxEVT_SCROLL_THUMBTRACK, wxScrollEventHandler( HerramientaOpcionesElevacionGUI::OnRadioScroll ), NULL, this );
 
109
                                m_pSliderRadio->Disconnect( wxEVT_SCROLL_THUMBRELEASE, wxScrollEventHandler( HerramientaOpcionesElevacionGUI::OnRadioScroll ), NULL, this );
 
110
                                m_pSliderRadio->Disconnect( wxEVT_SCROLL_CHANGED, wxScrollEventHandler( HerramientaOpcionesElevacionGUI::OnRadioScroll ), NULL, this );
 
111
 
 
112
                                m_pSliderFactor->Disconnect( wxEVT_SCROLL_TOP, wxScrollEventHandler( HerramientaOpcionesElevacionGUI::OnFactorScroll ), NULL, this );
 
113
                                m_pSliderFactor->Disconnect( wxEVT_SCROLL_BOTTOM, wxScrollEventHandler( HerramientaOpcionesElevacionGUI::OnFactorScroll ), NULL, this );
 
114
                                m_pSliderFactor->Disconnect( wxEVT_SCROLL_LINEUP, wxScrollEventHandler( HerramientaOpcionesElevacionGUI::OnFactorScroll ), NULL, this );
 
115
                                m_pSliderFactor->Disconnect( wxEVT_SCROLL_LINEDOWN, wxScrollEventHandler( HerramientaOpcionesElevacionGUI::OnFactorScroll ), NULL, this );
 
116
                                m_pSliderFactor->Disconnect( wxEVT_SCROLL_PAGEUP, wxScrollEventHandler( HerramientaOpcionesElevacionGUI::OnFactorScroll ), NULL, this );
 
117
                                m_pSliderFactor->Disconnect( wxEVT_SCROLL_PAGEDOWN, wxScrollEventHandler( HerramientaOpcionesElevacionGUI::OnFactorScroll ), NULL, this );
 
118
                                m_pSliderFactor->Disconnect( wxEVT_SCROLL_THUMBTRACK, wxScrollEventHandler( HerramientaOpcionesElevacionGUI::OnFactorScroll ), NULL, this );
 
119
                                m_pSliderFactor->Disconnect( wxEVT_SCROLL_THUMBRELEASE, wxScrollEventHandler( HerramientaOpcionesElevacionGUI::OnFactorScroll ), NULL, this );
 
120
                                m_pSliderFactor->Disconnect( wxEVT_SCROLL_CHANGED, wxScrollEventHandler( HerramientaOpcionesElevacionGUI::OnFactorScroll ), NULL, this );
 
121
                        }
 
122
 
 
123
 
 
124
                        virtual void OnRadioScroll( wxScrollEvent&  ){
 
125
                                m_pHerramienta->AjustarRadio((float)(m_pSliderRadio->GetValue()));
 
126
                        }
 
127
 
 
128
                        virtual void OnFactorScroll( wxScrollEvent&  ){
 
129
                                m_pHerramienta->AjustarSensibilidad((float)(m_pSliderFactor->GetValue())/GetRango());
 
130
                                wxString str = wxString::Format(_("Factor (%.2f)"),(float)(m_pSliderFactor->GetValue())/GetRango());
 
131
                                m_pLabelFactor->SetLabel(str);
 
132
                        }
 
133
 
 
134
                        virtual void OnBElevarClick( wxCommandEvent& event ){
 
135
                                m_pHerramienta->SetTipoAccion(GNC::TAE_AUMENTAR);
 
136
                                ToggleTool(DISMINUIR_VALORACION,false);
 
137
                                ToggleTool(ELEVAR_VALORACION,true);
 
138
                                event.Skip(false);
 
139
                        }
 
140
                        virtual void OnBDisminuirClick( wxCommandEvent& event ){
 
141
                                m_pHerramienta->SetTipoAccion(GNC::TAE_DISMINUIR);
 
142
                                ToggleTool(DISMINUIR_VALORACION,true);
 
143
                                ToggleTool(ELEVAR_VALORACION,false);
 
144
                                event.Skip(false);
 
145
                        }
 
146
 
 
147
                        void SetNumeroValores(int numeroValores)
 
148
                        {
 
149
                                m_pSliderFactor->SetMax(numeroValores);
 
150
                                if(numeroValores ==2) {
 
151
                                        m_pSliderFactor->SetValue(1);
 
152
                                        m_pHerramienta->AjustarSensibilidad((float)(m_pSliderFactor->GetValue())/GetRango());
 
153
                                        wxString str = wxString::Format(_("Factor (%.2f)"),(float)(m_pSliderFactor->GetValue())/GetRango());
 
154
                                        m_pLabelFactor->SetLabel(str);
 
155
                                        m_pSliderFactor->Show(false);
 
156
                                        m_pLabelFactor->Show(false);
 
157
                                } else {
 
158
                                        m_pSliderFactor->Show(true);
 
159
                                        m_pLabelFactor->Show(true);
 
160
                                }
 
161
                        }
 
162
 
 
163
                        int GetRango() {
 
164
                                return m_pSliderFactor->GetMax() - m_pSliderFactor->GetMin();
 
165
                        }
 
166
 
 
167
                        wxStaticText* m_pLabelFactor;
 
168
                        wxSlider* m_pSliderRadio;
 
169
                        wxSlider* m_pSliderFactor;
 
170
                        GNC::HerramientaElevacion* m_pHerramienta;
 
171
 
 
172
                };
 
173
        }
 
174
}
 
175
 
 
176
//----------------------------------------------------------------------
 
177
 
 
178
GNC::HerramientaElevacion::HerramientaElevacion()
 
179
{
 
180
        m_Activa = false;
 
181
        m_pElevacionBuilder = NULL;
 
182
 
 
183
        // Representacion 0: Semilla sana
 
184
 
 
185
        /* Configuracion del widget de semillas de elevacion. Atributos radiometricos de las semillas */
 
186
        GNC::GCS::Widgets::Elevacion::RepresentacionElevacion* pRep = NULL;
 
187
        m_radio=15.0f;
 
188
        m_sensibilidad=0.5f;
 
189
        m_TipoAccion=GNC::TAE_AUMENTAR;
 
190
 
 
191
        // Representacion 0: Semilla poner mas afectado
 
192
        pRep = new GNC::GCS::Widgets::Elevacion::RepresentacionElevacion();
 
193
        pRep->colorCircunferencia.asignar(0.5f, 0.0f, 0.0f, 0.5f);
 
194
        pRep->colorCircunferenciaIluminada.asignar(1.0f, 0.0f, 0.0f, 0.5f);
 
195
        pRep->m_RadioCircunferencia=m_radio;
 
196
        m_RepresentacionesElevacion.push_back(pRep);
 
197
 
 
198
        // Representacion 0: Semilla poner mas sano
 
199
        pRep = new GNC::GCS::Widgets::Elevacion::RepresentacionElevacion();
 
200
        pRep->colorCircunferencia.asignar(0.0f, 0.5f, 0.0f, 0.5f);
 
201
        pRep->colorCircunferenciaIluminada.asignar(0.0f, 1.0f, 0.0f, 0.5f);
 
202
        pRep->m_RadioCircunferencia=m_radio;
 
203
        m_RepresentacionesElevacion.push_back(pRep);
 
204
        m_PuntosInsertados.clear();
 
205
 
 
206
        m_Descripcion = _Std("Elevation");
 
207
 
 
208
        m_Icono = GinkgoResourcesManager::IconosHerramientas::GetIcoElevacion();
 
209
}
 
210
 
 
211
GNC::HerramientaElevacion::~HerramientaElevacion()
 
212
{
 
213
        for(GNC::GCS::Widgets::Elevacion::ListaRepresentaciones::iterator it = m_RepresentacionesElevacion.begin(); it != m_RepresentacionesElevacion.end(); it++) {
 
214
                delete *it;
 
215
        }
 
216
        m_RepresentacionesElevacion.clear();
 
217
 
 
218
        m_PuntosInsertados.clear();
 
219
}
 
220
 
 
221
//region "Realizaci�n de la interfaz IHerramienta"
 
222
 
 
223
void GNC::HerramientaElevacion::CrearPaneles( wxPanel* panel )
 
224
{
 
225
        m_pAbstractPanelHerramientaOpciones = new GNC::GUI::HerramientaOpcionesElevacionGUI(panel,this);
 
226
}
 
227
 
 
228
void GNC::HerramientaElevacion::ConectarContratoFalso(bool activar) {
 
229
        if (TContratableWidgets::m_pListaActiva == NULL) {
 
230
                //std::cerr << "Error: Se trato de activar el modo deshabilitado de una vista sin haber asignado la vista activa. Error en la logica de activacion. Accion ignorada" << std::endl;
 
231
                return;
 
232
        }
 
233
 
 
234
        for (TContratableWidgets::IteradorListaContratos it = TContratableWidgets::m_pListaActiva->begin(); it != TContratableWidgets::m_pListaActiva->end(); it++) {
 
235
                TContratoWidgets* pC = (*it);
 
236
                if (pC->Inicializado()) {
 
237
                        pC->GetManager()->EnableAnotacionDinamica(activar);
 
238
                        if (activar) {
 
239
                                GTRACE( "HerramientaElevacion: Conectando contrato falso de vista " << TContratableWidgets::m_pVistaActiva );
 
240
                                pC->GetViewer()->SetInteractionStyle(vtkGinkgoImageViewer::ZOOM_INTERACTION);
 
241
                                pC->GetManager()->SetCursor(GNC::GCS::Widgets::CUR_FLECHA);
 
242
                                pC->GetManager()->Render();
 
243
                        }
 
244
                        else {
 
245
                                GTRACE( "HerramientaElevacion: Desconectando contrato falso de vista " << TContratableWidgets::m_pVistaActiva );
 
246
                                pC->GetViewer()->SetInteractionStyle(vtkGinkgoImageViewer::ZOOM_INTERACTION);
 
247
                                pC->GetManager()->SetCursor(GNC::GCS::Widgets::CUR_FLECHA);
 
248
                        }
 
249
                }
 
250
        }
 
251
}
 
252
 
 
253
void GNC::HerramientaElevacion::SetVistaActiva(GNC::GCS::IVista* pVista) {
 
254
        TContratableWidgets::EstablecerVistaActiva(pVista);
 
255
        TContratableElevacion::EstablecerVistaActiva(pVista);
 
256
        GTRACE("GNC::TContratableElevacion::EstablecerVistaActiva(pVista);::SetVistaActiva(" <<  pVista << ")");
 
257
}
 
258
 
 
259
/* FIXME: Aviso!!!! para que funcione deben contratarse contratos pareados obligatorios y en el mismo orden*/
 
260
void GNC::HerramientaElevacion::ConectarContratos(bool activar)
 
261
{
 
262
        if (TContratableWidgets::m_pListaActiva == NULL || TContratableElevacion::m_pListaActiva == NULL) {
 
263
                if (activar) {
 
264
                        std::cerr << "Error: Se trataron de conectar contratos sin haber asignado la vista activa. Error en la logica de activacion. Accion ignorada" << std::endl;
 
265
                } else {
 
266
                        if(m_pElevacionBuilder != NULL) {
 
267
                                delete m_pElevacionBuilder;
 
268
                                m_pElevacionBuilder = NULL;
 
269
                        }
 
270
                }
 
271
                return;
 
272
        }
 
273
 
 
274
        if (TContratableWidgets::m_pListaActiva->size() != TContratableElevacion::m_pListaActiva->size()) {
 
275
                std::cerr << "Error: La vista tiene un numero distinto de contratos IContratoWidget que IContratoElevacion y de IcontratoAnotador. Imposible conectar" << std::endl;
 
276
                return;
 
277
        }
 
278
 
 
279
        // Recorrido de los contratos pareados: Contrato de widgets y Contrato específico de herramienta de semillas.
 
280
        TContratableWidgets::IteradorListaContratos it1 = TContratableWidgets::m_pListaActiva->begin();
 
281
        TContratableElevacion::IteradorListaContratos it2 = TContratableElevacion::m_pListaActiva->begin();
 
282
        for ( ; it1 != TContratableWidgets::m_pListaActiva->end() && it2 != TContratableElevacion::m_pListaActiva->end(); it1++, it2++) {
 
283
                TContratoWidgets* pCW = (*it1);
 
284
                TContratoElevacion* pCE = (*it2);
 
285
                if (pCW->Inicializado() && pCE->Inicializado()) {
 
286
                        pCW->GetManager()->EnableAnotacionDinamica(activar);
 
287
                        if (activar) {
 
288
                                GTRACE("HerramientaElevacion: Conectando contratos de vista " << pCW->m_pVista);
 
289
                                // Usamos de Id de grupo el valor del puntero de la herramienta, que es unico y no cambia
 
290
                                m_pElevacionBuilder = new GNC::GCS::Widgets::WElevacionBuilder(pCW->GetManager(), &m_RepresentacionesElevacion, (unsigned long)this);
 
291
                                if(m_TipoAccion==GNC::TAE_DISMINUIR){
 
292
                                        m_pElevacionBuilder->SetRepresentacionActiva(1);
 
293
                                }else{
 
294
                                        m_pElevacionBuilder->SetRepresentacionActiva(0);
 
295
                                }
 
296
                                //conectamos los observadores
 
297
                                m_pElevacionBuilder->SetObservador(this);
 
298
                                pCW->GetViewer()->SetInteractionStyle(vtkGinkgoImageViewer::ZOOM_INTERACTION);
 
299
                                pCW->GetManager()->SetCursor(m_pElevacionBuilder->GetCursor());
 
300
                                pCW->GetManager()->Render();
 
301
                                if(pCE->m_modoMascara) {
 
302
                                        ((GNC::GUI::HerramientaOpcionesElevacionGUI*)m_pAbstractPanelHerramientaOpciones)->SetNumeroValores(2);
 
303
                                } else {
 
304
                                        ((GNC::GUI::HerramientaOpcionesElevacionGUI*)m_pAbstractPanelHerramientaOpciones)->SetNumeroValores((pCE->m_maximo-pCE->m_minimo)+1);
 
305
                                }
 
306
                        }
 
307
                        else {
 
308
                                GTRACE( "HerramientaElevacion: Desconectando contratos de vista " << pCW->m_pVista );
 
309
                                if(m_pElevacionBuilder != NULL) {
 
310
                                        delete m_pElevacionBuilder;
 
311
                                        m_pElevacionBuilder = NULL;
 
312
                                }
 
313
                                //se borra la semilla
 
314
                                for(GNC::GCS::IWidgetsManager::IteradorListaWidgets it2 = pCW->GetManager()->GetListaWidgets().begin(); it2 != pCW->GetManager()->GetListaWidgets().end(); it2++){
 
315
                                        if((*it2)->GetGID() == (long)this){
 
316
                                                pCW->GetManager()->EliminarWidget(*it2,false);
 
317
                                                break;
 
318
                                        }
 
319
                                }
 
320
                                pCW->GetViewer()->SetInteractionStyle(vtkGinkgoImageViewer::ZOOM_INTERACTION);
 
321
                                pCW->GetManager()->SetCursor(GNC::GCS::Widgets::CUR_FLECHA);
 
322
                        }
 
323
                }
 
324
        }
 
325
}
 
326
 
 
327
//endregion
 
328
 
 
329
 
 
330
//region "Eventos refinados desde los paneles"
 
331
 
 
332
//endregion
 
333
 
 
334
//region "metodos propios de la varita"
 
335
 
 
336
void GNC::HerramientaElevacion::OnPuntoInsertado(float x, float y) {
 
337
 
 
338
        if (TContratableElevacion::m_pListaActiva == NULL) {
 
339
                std::cerr << "Error: Se trataron de conectar contratos sin haber asignado la vista activa. Error en la logica de activacion. Accion ignorada" << std::endl;
 
340
                return;
 
341
        }
 
342
 
 
343
        m_PuntosInsertados.push_back(GNC::GCS::Vector(x,y));
 
344
}
 
345
 
 
346
void GNC::HerramientaElevacion::OnTerminarInsertar() {
 
347
 
 
348
        if (TContratableElevacion::m_pListaActiva == NULL) {
 
349
                std::cerr << "Error: Se trataron de conectar contratos sin haber asignado la vista activa. Error en la logica de activacion. Accion ignorada" << std::endl;
 
350
                return;
 
351
        }
 
352
 
 
353
 
 
354
        TContratableWidgets::IteradorListaContratos it1 = TContratableWidgets::m_pListaActiva->begin();
 
355
        for (TContratableElevacion::IteradorListaContratos it = TContratableElevacion::m_pListaActiva->begin(); it != TContratableElevacion::m_pListaActiva->end()&&it1 != TContratableWidgets::m_pListaActiva->end(); it++,it1++) {
 
356
                GNC::GCS::IContratoElevacion* pC = (*it);
 
357
                //TContratoWidgets* pCW = (*it1);
 
358
                if(pC!=NULL && pC->m_pMapaValoracion != NULL){
 
359
                        int dimensiones[3];
 
360
                        pC->m_pMapaValoracion->GetDimensions(dimensiones);
 
361
                        unsigned char* img = new unsigned char[dimensiones[0]*dimensiones[1]];
 
362
 
 
363
                        GNC::GCS::Vector p;
 
364
                        GNC::GCS::Vector d;
 
365
                        unsigned int ix, iy;
 
366
                        unsigned int off = 0;
 
367
                        unsigned int size = dimensiones[0]*dimensiones[1];
 
368
                        for(; off<size; ++off)
 
369
                                img[off] = 0;
 
370
 
 
371
                        off = 0;
 
372
 
 
373
                        // TODO: Arreglar todo esto. Podría ser elíptico
 
374
                        //float radio = m_radio / std::max(vSpacing.x, vSpacing.y);
 
375
 
 
376
                        for (TipoIteradorPuntosInsertados it = m_PuntosInsertados.begin(); it!= m_PuntosInsertados.end(); ++it) {
 
377
                                GNC::GCS::Vector n = (*it);
 
378
                                float nNorma2Cuadrado = (m_radio * m_radio);
 
379
                                for (int y = (n.y - m_radio); y < (n.y + m_radio); ++y) {
 
380
                                        iy = y; // Correccion de coordenadas ??????????????????
 
381
                                        if (iy >= 0 && iy < (unsigned int)dimensiones[1]) {
 
382
                                                for (int x = (n.x - m_radio); x < (n.x + m_radio); ++x) {
 
383
                                                        ix = x;
 
384
                                                        if (ix >= 0 && ix < (unsigned int)dimensiones[0]) {
 
385
                                                                off = iy * dimensiones[0] + ix;
 
386
                                                                d = n - (GNC::GCS::Vector(x, y));
 
387
                                                                if (img[off] == 0) {
 
388
                                                                        if (d.Norma2Cuadrado() < nNorma2Cuadrado) {
 
389
                                                                                img[off] = 255;
 
390
                                                                        }
 
391
                                                                }
 
392
                                                        }
 
393
                                                }
 
394
                                        }
 
395
                                }
 
396
                        }
 
397
 
 
398
                        off = 0;
 
399
 
 
400
                        if(pC->m_modoMascara) {
 
401
                                unsigned char maskSet = pC->m_mascaraSet;
 
402
                                unsigned char maskUnset = pC->m_mascaraUnSet;
 
403
                                unsigned char* data = (unsigned char*) pC->m_pMapaValoracion->GetScalarPointer();
 
404
 
 
405
                                if(m_TipoAccion==GNC::TAE_AUMENTAR){
 
406
                                        for (off = 0; off < size; off++) {
 
407
                                                if (img[off] == 255) {
 
408
                                                        data[off] |= maskSet;
 
409
                                                }
 
410
                                        }
 
411
                                } else {
 
412
                                        for (off = 0; off < size; off++) {
 
413
                                                if (img[off] == 255) {
 
414
                                                        data[off] &= maskUnset;
 
415
                                                }
 
416
                                        }
 
417
                                }
 
418
                        } else {
 
419
                                double valor;
 
420
                                const int st = pC->m_pMapaValoracion->GetScalarType();
 
421
                                const double maximo = pC->m_maximo;
 
422
                                const double minimo = pC->m_minimo;
 
423
                                double factor = m_sensibilidad * (pC->m_maximo-pC->m_minimo+1);
 
424
 
 
425
                                switch(st) {
 
426
                                        case VTK_DOUBLE:
 
427
                                                {
 
428
                                                        double* data = (double*) pC->m_pMapaValoracion->GetScalarPointer();
 
429
                                                        for (off = 0; off < size; off++) {
 
430
                                                                if (img[off] == 255) {
 
431
                                                                        if(m_TipoAccion==GNC::TAE_AUMENTAR){
 
432
                                                                                valor = std::min( (data[off] + factor) ,maximo);
 
433
                                                                        }
 
434
                                                                        else{
 
435
                                                                                valor = std::max( (data[off]-factor) ,minimo);
 
436
                                                                        }
 
437
                                                                        data[off] = valor;
 
438
                                                                }
 
439
                                                        }
 
440
                                                }
 
441
                                                break;
 
442
                                        case VTK_FLOAT:
 
443
                                                {
 
444
                                                        float* data = (float*) pC->m_pMapaValoracion->GetScalarPointer();
 
445
                                                        for (off = 0; off < size; off++) {
 
446
                                                                if (img[off] == 255) {
 
447
                                                                        if(m_TipoAccion==GNC::TAE_AUMENTAR){
 
448
                                                                                valor = std::min( (double)(data[off] + factor) ,maximo);
 
449
                                                                        }
 
450
                                                                        else{
 
451
                                                                                valor = std::max( (double)(data[off]-factor) ,minimo);
 
452
                                                                        }
 
453
                                                                        data[off] = (float)valor;
 
454
                                                                }
 
455
                                                        }
 
456
                                                }
 
457
                                                break;
 
458
                                        case VTK_UNSIGNED_LONG:
 
459
                                                {
 
460
                                                        unsigned long* data = (unsigned long*) pC->m_pMapaValoracion->GetScalarPointer();
 
461
                                                        for (off = 0; off < size; off++) {
 
462
                                                                if (img[off] == 255) {
 
463
                                                                        if(m_TipoAccion==GNC::TAE_AUMENTAR){
 
464
                                                                                valor = std::min( (double)(data[off] + factor) ,maximo);
 
465
                                                                        }
 
466
                                                                        else{
 
467
                                                                                valor = std::max( (double)(data[off]-factor) ,minimo);
 
468
                                                                        }
 
469
                                                                        data[off] = (unsigned long)valor;
 
470
                                                                }
 
471
                                                        }
 
472
                                                }
 
473
                                                break;
 
474
                                        case VTK_LONG:
 
475
                                                {
 
476
                                                        long* data = (long*) pC->m_pMapaValoracion->GetScalarPointer();
 
477
                                                        for (off = 0; off < size; off++) {
 
478
                                                                if (img[off] == 255) {
 
479
                                                                        if(m_TipoAccion==GNC::TAE_AUMENTAR){
 
480
                                                                                valor = std::min( (double)(data[off] + factor) ,maximo);
 
481
                                                                        }
 
482
                                                                        else{
 
483
                                                                                valor = std::max( (double)(data[off]-factor) ,minimo);
 
484
                                                                        }
 
485
                                                                        data[off] = (long)valor;
 
486
                                                                }
 
487
                                                        }
 
488
                                                }
 
489
                                                break;
 
490
                                        case VTK_UNSIGNED_INT:
 
491
                                                {
 
492
                                                        unsigned int* data = (unsigned int*) pC->m_pMapaValoracion->GetScalarPointer();
 
493
                                                        for (off = 0; off < size; off++) {
 
494
                                                                if (img[off] == 255) {
 
495
                                                                        if(m_TipoAccion==GNC::TAE_AUMENTAR){
 
496
                                                                                valor = std::min( (double)(data[off] + factor) ,maximo);
 
497
                                                                        }
 
498
                                                                        else{
 
499
                                                                                valor = std::max( (double)(data[off]-factor) ,minimo);
 
500
                                                                        }
 
501
                                                                        data[off] = (unsigned int)valor;
 
502
                                                                }
 
503
                                                        }
 
504
                                                }
 
505
                                                break;
 
506
                                        case VTK_INT:
 
507
                                                {
 
508
                                                        int* data = (int*) pC->m_pMapaValoracion->GetScalarPointer();
 
509
                                                        for (off = 0; off < size; off++) {
 
510
                                                                if (img[off] == 255) {
 
511
                                                                        if(m_TipoAccion==GNC::TAE_AUMENTAR){
 
512
                                                                                valor = std::min( (double)(data[off] + factor) ,maximo);
 
513
                                                                        }
 
514
                                                                        else{
 
515
                                                                                valor = std::max( (double)(data[off]-factor) ,minimo);
 
516
                                                                        }
 
517
                                                                        data[off] = (int)valor;
 
518
                                                                }
 
519
                                                        }
 
520
                                                }
 
521
                                                break;
 
522
                                        case VTK_UNSIGNED_SHORT:
 
523
                                                {
 
524
                                                        unsigned short* data = (unsigned short*) pC->m_pMapaValoracion->GetScalarPointer();
 
525
                                                        for (off = 0; off < size; off++) {
 
526
                                                                if (img[off] == 255) {
 
527
                                                                        if(m_TipoAccion==GNC::TAE_AUMENTAR){
 
528
                                                                                valor = std::min( (double)(data[off] + factor) ,maximo);
 
529
                                                                        }
 
530
                                                                        else{
 
531
                                                                                valor = std::max( (double)(data[off]-factor) ,minimo);
 
532
                                                                        }
 
533
                                                                        data[off] = (unsigned short)valor;
 
534
                                                                }
 
535
                                                        }
 
536
                                                }
 
537
                                                break;
 
538
                                        case VTK_SHORT:
 
539
                                                {
 
540
                                                        short* data = (short*) pC->m_pMapaValoracion->GetScalarPointer();
 
541
                                                        for (off = 0; off < size; off++) {
 
542
                                                                if (img[off] == 255) {
 
543
                                                                        if(m_TipoAccion==GNC::TAE_AUMENTAR){
 
544
                                                                                valor = std::min( (double)(data[off] + factor) ,maximo);
 
545
                                                                        }
 
546
                                                                        else{
 
547
                                                                                valor = std::max( (double)(data[off]-factor) ,minimo);
 
548
                                                                        }
 
549
                                                                        data[off] = (short)valor;
 
550
                                                                }
 
551
                                                        }
 
552
                                                }
 
553
                                                break;
 
554
                                        case VTK_UNSIGNED_CHAR:
 
555
                                                {
 
556
                                                        unsigned char* data = (unsigned char*) pC->m_pMapaValoracion->GetScalarPointer();
 
557
                                                        for (off = 0; off < size; off++) {
 
558
                                                                if (img[off] == 255) {
 
559
                                                                        if(m_TipoAccion==GNC::TAE_AUMENTAR){
 
560
                                                                                valor = std::min( (double)(data[off] + factor) ,maximo);
 
561
                                                                        }
 
562
                                                                        else{
 
563
                                                                                valor = std::max( (double)(data[off]-factor) ,minimo);
 
564
                                                                        }
 
565
                                                                        data[off] = (unsigned char)valor;
 
566
                                                                }
 
567
                                                        }
 
568
                                                }
 
569
                                                break;
 
570
                                        case VTK_CHAR:
 
571
                                                {
 
572
                                                        char* data = (char*) pC->m_pMapaValoracion->GetScalarPointer();
 
573
                                                        for (off = 0; off < size; off++) {
 
574
                                                                if (img[off] == 255) {
 
575
                                                                        if(m_TipoAccion==GNC::TAE_AUMENTAR){
 
576
                                                                                valor = std::min( (double)(data[off] + factor) ,maximo);
 
577
                                                                        }
 
578
                                                                        else{
 
579
                                                                                valor = std::max( (double)(data[off]-factor) ,minimo);
 
580
                                                                        }
 
581
                                                                        data[off] = (char)valor;
 
582
                                                                }
 
583
                                                        }
 
584
                                                }
 
585
                                                break;
 
586
                                }
 
587
                        }
 
588
 
 
589
                        delete [] img;
 
590
 
 
591
                        pC->m_pMapaValoracion->Modified();
 
592
                        pC->m_pNotificador->ActualizarVistaElevacion();
 
593
                }
 
594
        }
 
595
        m_PuntosInsertados.clear();
 
596
}
 
597
 
 
598
void GNC::HerramientaElevacion::AjustarSensibilidad(float valorNormalizado) {
 
599
        m_sensibilidad=valorNormalizado;
 
600
}
 
601
 
 
602
void GNC::HerramientaElevacion::AjustarRadio(float valor) {
 
603
        for(GNC::GCS::Widgets::Elevacion::ListaRepresentaciones::iterator it = m_RepresentacionesElevacion.begin(); it != m_RepresentacionesElevacion.end(); it++) {
 
604
                (*it)->m_RadioCircunferencia=valor;
 
605
        }
 
606
 
 
607
        m_radio=valor;
 
608
 
 
609
        for ( TContratableWidgets::IteradorListaContratos it1 = TContratableWidgets::m_pListaActiva->begin(); it1 != TContratableWidgets::m_pListaActiva->end() ; it1++) {
 
610
                TContratoWidgets* pCW = (*it1);
 
611
                pCW->GetManager()->Modificado();
 
612
        }
 
613
}
 
614
 
 
615
void GNC::HerramientaElevacion::SetTipoAccion(GNC::TipoAccionElevacion tipoAccion){
 
616
        m_TipoAccion=tipoAccion;
 
617
        if(m_pElevacionBuilder!=NULL){
 
618
                if(m_TipoAccion==GNC::TAE_DISMINUIR){
 
619
                        m_pElevacionBuilder->SetRepresentacionActiva(1);
 
620
                }else{
 
621
                        m_pElevacionBuilder->SetRepresentacionActiva(0);
 
622
                }
 
623
                for ( TContratableWidgets::IteradorListaContratos it1 = TContratableWidgets::m_pListaActiva->begin(); it1 != TContratableWidgets::m_pListaActiva->end() ; it1++) {
 
624
                        TContratoWidgets* pCW = (*it1);
 
625
                        pCW->GetManager()->Modificado();
 
626
                }
 
627
        }
 
628
}
 
629
 
 
630
//endregion