source: eviacam/trunk/fuentes/wxcamwindow/visiblenormroi.cpp @ 29

Last change on this file since 29 was 29, checked in by mabarracus, 4 years ago

added eviacam content

  • Property svn:executable set to *
File size: 10.8 KB
Line 
1/////////////////////////////////////////////////////////////////////////////
2// Name:        visiblenormroi.cpp
3// Purpose:             
4// Author:      Cesar Mauri Loba (cesar at crea-si dot com)
5// Modified by:
6// Created:     
7// Copyright:   (C) 2008 Cesar Mauri Loba - CREA Software Systems
8//
9//  This program is free software: you can redistribute it and/or modify
10//  it under the terms of the GNU General Public License as published by
11//  the Free Software Foundation, either version 3 of the License, or
12//  (at your option) any later version.
13//
14//  This program is distributed in the hope that it will be useful,
15//  but WITHOUT ANY WARRANTY; without even the implied warranty of
16//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
17//  GNU General Public License for more details.
18//
19//  You should have received a copy of the GNU General Public License
20//  along with this program.  If not, see <http://www.gnu.org/licenses/>.
21/////////////////////////////////////////////////////////////////////////////
22#include "visiblenormroi.h"
23
24#define SELECTION_TOLERANCE 3
25
26CVisibleNormROI::CVisibleNormROI(void) : CNormROI()
27{               
28        m_cursorOver= OVER_NONE;
29        m_showOrientation= false;
30        m_degradation= 0;
31}
32
33CVisibleNormROI::CVisibleNormROI(float width, float height, float x, float y) : 
34        CNormROI (width, height, x, y)
35{
36        m_cursorOver= OVER_NONE;
37        m_showOrientation= false;
38        m_degradation= 0;
39}
40
41CVisibleNormROI::~CVisibleNormROI(void)
42{
43}
44
45//
46// Locking support. Locks on parent
47//
48inline void CVisibleNormROI::Lock()
49{
50        if (m_pParentROI)
51                ((CVisibleNormROI *) m_pParentROI)->Lock();
52        else
53                m_CriticalSection.Enter();
54}
55
56inline void CVisibleNormROI::Unlock()
57{
58        if (m_pParentROI)
59                ((CVisibleNormROI *) m_pParentROI)->Unlock();
60        else
61                m_CriticalSection.Leave();     
62}
63       
64
65
66void CVisibleNormROI::SetP1Resize (const float x, const float y)
67{
68        Lock();
69
70        CNormROI::SetP1Resize (x, y);
71       
72        Unlock();
73}
74
75void CVisibleNormROI::SetP1Move (const float x, const float y)
76{
77        Lock();
78
79        CNormROI::SetP1Move (x, y);
80       
81        Unlock();
82}
83
84void CVisibleNormROI::SetP2Resize (const float x, const float y)
85{
86        Lock();
87
88        CNormROI::SetP2Resize (x, y);
89       
90        Unlock();
91}
92
93void CVisibleNormROI::SetCenter (const float x, const float y)
94{
95        Lock();
96
97        CNormROI::SetCenter (x, y);
98       
99        Unlock();
100}
101
102void CVisibleNormROI::GetCenter (float& x, float& y)
103{
104        Lock();
105
106        CNormROI::GetCenter (x, y);
107       
108        Unlock();
109}
110
111void CVisibleNormROI::SetSize (const float width, const float height)
112{
113        Lock();
114
115        CNormROI::SetSize (width, height);
116       
117        Unlock();
118}
119
120void CVisibleNormROI::GetSize (float& width, float& height)
121{
122        Lock();
123
124        CNormROI::GetSize (width, height);
125       
126        Unlock();
127}
128
129// Overriden IPL methods to support locking
130void CVisibleNormROI::SetP1ResizeImg (const CIplImage *pImg, const int x, const int y)
131{
132        Lock();
133
134        CNormROI::SetP1ResizeImg (pImg, x, y);
135
136        Unlock();
137}
138
139void CVisibleNormROI::SetP1MoveImg (const CIplImage *pImg, const int x, const int y)
140{
141        Lock();
142
143        CNormROI::SetP1MoveImg (pImg, x, y);
144
145        Unlock();
146}
147
148void CVisibleNormROI::SetP2ResizeImg (const CIplImage *pImg, const int x, const int y)
149{
150        Lock();
151
152        CNormROI::SetP2ResizeImg (pImg, x, y);
153
154        Unlock();
155}
156
157void CVisibleNormROI::SetCenterImg (const CIplImage *pImg, const int x, const int y)
158{
159        Lock();
160
161        CNormROI::SetCenterImg (pImg, x, y);
162
163        Unlock();
164}
165
166void CVisibleNormROI::GetCenterImg (const CIplImage *pImg, int& x, int& y)
167{
168        Lock();
169
170        CNormROI::GetCenterImg (pImg, x, y);
171
172        Unlock();
173}
174
175void CVisibleNormROI::SetSizeImg (const CIplImage *pImg, const int width, const int height)
176{
177        Lock();
178
179        CNormROI::SetSizeImg (pImg, width, height);
180
181        Unlock();
182}
183
184void CVisibleNormROI::GetBoxImg (const CIplImage *pImg, int& x, int& y, int& width, int& height)
185{
186        Lock();
187
188        CNormROI::GetBoxImg (pImg, x, y, width, height);
189
190        Unlock();
191}
192
193void CVisibleNormROI::GetBoxImg (const CIplImage *pImg, CvRect& box)
194{
195        Lock();
196
197        CNormROI::GetBoxImg (pImg, box);
198
199        Unlock();
200}
201
202bool CVisibleNormROI::RegisterChildROI (CVisibleNormROI* pNormROI) 
203{ 
204        // Ensures that child is really a CVisibleNormROI object
205        // (perhaps somewhat paranoic hehe)
206        if (!dynamic_cast<CVisibleNormROI *>(pNormROI))
207        {
208                assert (false);
209                return false;
210        }
211
212        // Lock child
213        pNormROI->m_CriticalSection.Enter();
214
215        // Lock this
216        Lock();
217
218        bool retval= CNormROI::RegisterChildROI (pNormROI);
219
220        // Unlock child
221        pNormROI->m_CriticalSection.Leave();
222
223        // Unlock this
224        Unlock();
225
226        return retval;
227}
228
229bool CVisibleNormROI::UnregisterChildROI (CVisibleNormROI* pNormROI)
230{
231        Lock();
232
233        bool retval= CNormROI::UnregisterChildROI (pNormROI);
234
235        Unlock();
236
237        return retval;
238}
239
240
241//
242// Interaction code
243//
244void CVisibleNormROI::GetDirectionSegment (const CvSize& winSize, CvPoint& p1, CvPoint& p2)
245{
246        GetP1P2Integer (winSize, p1, p2);
247        float line_lenght= sqrtf (
248                powf((float)(p2.x - p1.x), 2.0f) + 
249                powf((float)(p2.y - p1.y), 2.0f)) * 1.1f / 2.0f;
250       
251        float cx= (float)(p1.x + p2.x) / 2.0f;
252        float cy= (float)(p1.y + p2.y) / 2.0f;
253
254        p1.x= (int) (cx + 0.5f); 
255        p1.y= (int) (cy + 0.5f);
256        p2.x= (int) (cx + (line_lenght) * cos (GetRotation()) + 0.5f);
257        p2.y= (int) (cy - (line_lenght) * sin (GetRotation()) + 0.5f);
258}
259
260// Cursor motion, no click
261int CVisibleNormROI::OnMouseMovedNoClick (const CvSize& winSize, const CvPoint& cursor)
262{
263        Lock ();
264
265        int retval= OnMouseMovedNoClickRec (winSize, cursor);
266
267        Unlock();
268
269        return retval;
270}
271
272int CVisibleNormROI::OnMouseMovedNoClickRec (const CvSize& winSize, const CvPoint& cursor)
273{
274        int retval;
275        TNormROIListIterator i;
276
277        retval= OnMouseMovedNoClick0 (winSize, cursor);
278        if (retval!= OVER_NONE) return retval;
279
280        for(i= m_childROIs.begin(); i != m_childROIs.end(); ++i)
281        {
282                CVisibleNormROI* pChild= dynamic_cast<CVisibleNormROI *>(*i);
283                assert (pChild);
284                retval= pChild->OnMouseMovedNoClickRec (winSize, cursor);
285                if (retval!= OVER_NONE) return retval;
286        }       
287        return OVER_NONE;
288}
289
290int CVisibleNormROI::OnMouseMovedNoClick0 (const CvSize& winSize, const CvPoint& cursor)
291{
292        CvPoint p1, p2, or_p1, or_p2;
293       
294        GetDirectionSegment (winSize, or_p1, or_p2);
295        GetP1P2Integer (winSize, p1, p2);
296               
297        // Motion only. Used to update mouse pointer.
298        m_cursorOver= OVER_NONE;
299
300        if (m_showOrientation && cursor.x>= or_p2.x - SELECTION_TOLERANCE && cursor.x<= or_p2.x + SELECTION_TOLERANCE &&
301                cursor.y>= or_p2.y - SELECTION_TOLERANCE && cursor.y<= or_p2.y + SELECTION_TOLERANCE)
302        {
303                m_cursorOver= OVER_ORIENTER;
304        }
305        else if (cursor.x>= p1.x - SELECTION_TOLERANCE && cursor.x<= p1.x + SELECTION_TOLERANCE &&
306                         cursor.y>= p1.y - SELECTION_TOLERANCE && cursor.y<= p1.y + SELECTION_TOLERANCE)
307        {
308                m_cursorOver= OVER_UL_CORNER;
309        }
310        else if (cursor.x>= p2.x - SELECTION_TOLERANCE && cursor.x<= p2.x + SELECTION_TOLERANCE &&
311                         cursor.y>= p2.y - SELECTION_TOLERANCE && cursor.y<= p2.y + SELECTION_TOLERANCE)
312        {       
313                m_cursorOver= OVER_BR_CORNER;
314        }
315        else
316        {
317                if (cursor.y>= p1.y - SELECTION_TOLERANCE && cursor.y<= p2.y + SELECTION_TOLERANCE)
318                {
319                        // Cursor in Y range, check is cursor over vertical lines
320                        if (cursor.x>= p1.x - SELECTION_TOLERANCE && cursor.x<= p1.x + SELECTION_TOLERANCE) 
321                                m_cursorOver= OVER_LEFT_LINE;
322                        else if (cursor.x>= p2.x - SELECTION_TOLERANCE && cursor.x<= p2.x + SELECTION_TOLERANCE)
323                                m_cursorOver= OVER_RIGHT_LINE;
324                }
325                if (cursor.x>= p1.x - SELECTION_TOLERANCE && cursor.x<= p2.x + SELECTION_TOLERANCE)
326                {
327                        // Cursor in X range, check is cursor over horizontal lines
328                        if (cursor.y>=  p1.y - SELECTION_TOLERANCE && cursor.y<=  p1.y + SELECTION_TOLERANCE) 
329                                m_cursorOver= OVER_UPPER_LINE;
330                        else if (cursor.y>= p2.y - SELECTION_TOLERANCE && cursor.y<= p2.y + SELECTION_TOLERANCE)
331                                m_cursorOver= OVER_BOTTOM_LINE;
332                }
333        }       
334
335        return m_cursorOver;
336}
337
338// Cursor motion, left button down
339bool CVisibleNormROI::OnMouseMovedClick (const CvSize& winSize, const CvPoint& cursor, const CvPoint& prevCursor)
340{
341        Lock ();
342
343        bool retval= OnMouseMovedClickRec (winSize, cursor, prevCursor);
344
345        Unlock();
346
347        return retval;
348}
349
350bool CVisibleNormROI::OnMouseMovedClickRec (const CvSize& winSize, const CvPoint& cursor, const CvPoint& prevCursor)
351{
352        TNormROIListIterator i;
353
354        if (OnMouseMovedClick0 (winSize, cursor, prevCursor)) return true;
355
356        for(i= m_childROIs.begin(); i != m_childROIs.end(); ++i)
357        {
358                CVisibleNormROI* pChild= dynamic_cast<CVisibleNormROI *>(*i);
359                assert (pChild);
360                if (pChild->OnMouseMovedClickRec (winSize, cursor, prevCursor)) return true;           
361        }       
362        return false;
363}
364
365bool CVisibleNormROI::OnMouseMovedClick0 (const CvSize& winSize, const CvPoint& cursor, const CvPoint& prevCursor)
366{
367        CvPoint p1, p2, or_p1, or_p2;
368       
369        GetDirectionSegment (winSize, or_p1, or_p2);
370        GetP1P2Integer (winSize, p1, p2);
371               
372        if (m_cursorOver> OVER_NONE)
373        {               
374                switch (m_cursorOver)
375                {
376                        case OVER_LEFT_LINE: 
377                                p1.x+= cursor.x - prevCursor.x;                                 
378                                SetP1ResizeInteger (winSize, p1.x, p1.y);
379                                break;
380                        case OVER_BOTTOM_LINE: 
381                                p2.y+= cursor.y - prevCursor.y;
382                                SetP2ResizeInteger (winSize, p2.x, p2.y);
383                                break;
384                        case OVER_RIGHT_LINE: 
385                                p2.x+= cursor.x - prevCursor.x;
386                                SetP2ResizeInteger (winSize, p2.x, p2.y);
387                                break;                 
388                        case OVER_UPPER_LINE: 
389                                p1.y+= cursor.y - prevCursor.y;                                 
390                                SetP1ResizeInteger (winSize, p1.x, p1.y);
391                                break;
392                        case OVER_ORIENTER:                             
393                                or_p2.x= cursor.x;
394                                or_p2.y= cursor.y;
395                                SetRotation (atan2f((float) (or_p1.y - or_p2.y), (float) (or_p2.x - or_p1.x)));
396                                break;
397                        case OVER_UL_CORNER:
398                        case OVER_BR_CORNER:
399                                p1.x+= cursor.x - prevCursor.x;
400                                p1.y+= cursor.y - prevCursor.y;                 
401                                SetP1MoveInteger (winSize, p1.x, p1.y);
402                                break;
403                }
404                return true;
405        }
406        return false;
407}
408
409// Painting
410void CVisibleNormROI::OnPaint (const CvSize& winSize, CIplImage *pImg)
411{
412        Lock ();
413        OnPaintRec (winSize, pImg);
414        Unlock();
415}
416
417void CVisibleNormROI::OnPaintRec (const CvSize& winSize, CIplImage *pImg)
418{               
419        TNormROIListIterator i;
420
421        for(i= m_childROIs.begin(); i != m_childROIs.end(); ++i)
422        {
423                CVisibleNormROI* pChild= dynamic_cast<CVisibleNormROI *>(*i);
424                assert (pChild);
425                pChild->OnPaintRec (winSize, pImg);
426        }       
427        OnPaint0 (winSize, pImg);
428}
429
430void CVisibleNormROI::OnPaint0 (const CvSize& winSize, CIplImage *pImg)
431{
432        int thickness;
433       
434        CvPoint p1, p2;
435        GetP1P2Integer (winSize, p1, p2);
436
437        if (m_cursorOver>= OVER_LEFT_LINE && m_cursorOver<= OVER_BR_CORNER)  thickness= 3;
438        else thickness= 1;
439        cvRectangle (pImg->ptr(), p1, p2, CV_RGB( 255-m_degradation, 255-m_degradation, m_degradation ), thickness, 4);
440
441        // Affordances
442        CvPoint pa, pb;
443        pa.x= p1.x - thickness;
444        pa.y= p1.y - thickness;
445        pb.x= p1.x + thickness;
446        pb.y= p1.y + thickness;
447
448        cvRectangle (pImg->ptr(), pa, pb, CV_RGB( 255-m_degradation, 255-m_degradation, m_degradation ), CV_FILLED );
449
450        pa.x= p2.x - thickness;
451        pa.y= p2.y - thickness;
452        pb.x= p2.x + thickness;
453        pb.y= p2.y + thickness;
454
455        cvRectangle (pImg->ptr(), pa, pb, CV_RGB( 255-m_degradation, 255-m_degradation, m_degradation ), CV_FILLED );
456
457        GetDirectionSegment (winSize, p1, p2);
458       
459        if (m_showOrientation)
460        {
461                if (m_cursorOver== OVER_ORIENTER)  thickness= 3;
462                else thickness= 1;
463                cvLine (pImg->ptr(), p1, p2, CV_RGB( 255,255,0 ), thickness, CV_AA );
464                cvCircle(pImg->ptr(), p2, SELECTION_TOLERANCE, CV_RGB( 255,255,0 ), thickness, CV_AA );
465        }
466}
Note: See TracBrowser for help on using the repository browser.