00001
00002
00003
00004
00005
00006
00007
00008
00009 #ifndef KOGMO_RTDB_OBJ_BASE_SYSTEM_CLASSES_HXX
00010 #define KOGMO_RTDB_OBJ_BASE_SYSTEM_CLASSES_HXX
00011
00012 #include "kogmo_rtdb.hxx"
00013 #include <sstream>
00014 #include <cmath>
00015 #include <stdio.h>
00016 using namespace std;
00017
00018 namespace KogniMobil {
00019
00020
00021
00022
00023
00024
00025
00026
00027
00028 typedef RTDBObj_T < kogmo_rtdb_subobj_c3_playerstat_t, KOGMO_RTDB_OBJTYPE_C3_PLAYERSTAT, RTDBObj > C3_PlayerStat_T;
00029 class C3_PlayerStat : public C3_PlayerStat_T
00030 {
00031 public:
00032 C3_PlayerStat(class RTDBConn& DBC, const char* name = "") : C3_PlayerStat_T (DBC, name)
00033 {
00034 }
00035 std::string dump (void) const
00036 {
00037 std::ostringstream ostr;
00038 ostr << "* Player Status :" << std::endl
00039 << "Begin of Recording: " << Timestamp(subobj_p->first_ts).string() << std::endl
00040 << "Latest Time in Recording: " << Timestamp(subobj_p->last_ts).string() << std::endl
00041 << "Current Time Playing: " << Timestamp(subobj_p->current_ts).string()
00042 << " ( " << (Timestamp(subobj_p->current_ts)-Timestamp(subobj_p->first_ts)) << " secs )" << std::endl;
00043 return RTDBObj::dump() + ostr.str();
00044 };
00045 };
00046
00047 typedef RTDBObj_T < kogmo_rtdb_subobj_c3_playerctrl_t, KOGMO_RTDB_OBJTYPE_C3_PLAYERCTRL, RTDBObj > C3_PlayerCtrl_T;
00048 class C3_PlayerCtrl : public C3_PlayerCtrl_T
00049 {
00050 public:
00051 C3_PlayerCtrl(class RTDBConn& DBC, const char* name = "") : C3_PlayerCtrl_T (DBC, name)
00052 {
00053 }
00054 void RTDBWrite (int32_t size = 0, Timestamp ts = 0)
00055 {
00056
00057
00058 Timestamp LastTS = getDataTimestamp();
00059 setDataTimestamp();
00060 if ( LastTS == getDataTimestamp() )
00061 setDataTimestamp( 1 + LastTS );
00062 RTDBObj::RTDBWrite (size,ts);
00063 }
00064 std::string dump (void) const
00065 {
00066 std::ostringstream ostr;
00067 ostr << "* Player Control :" << std::endl
00068 << "Pause: " << (subobj_p->flags.pause ? "ON" : "off") << std::endl
00069 << "Scanning: " << (subobj_p->flags.scan ? "ON" : "off") << std::endl
00070 << "Logging: " << (subobj_p->flags.log ? "ON" : "off") << std::endl
00071 << "Loop: " << (subobj_p->flags.loop ? "ON" : "off") << std::endl
00072 << "KeepCreated:" << (subobj_p->flags.keepcreated ? "ON" : "off") << std::endl
00073 << "Speed :" << (subobj_p->speed*100.0) << "%" << std::endl
00074 << "Loop Start: " << Timestamp(subobj_p->begin_ts).string() << std::endl
00075 << "Loop End: " << Timestamp(subobj_p->end_ts).string() << std::endl
00076 << "GoTo Time: " << Timestamp(subobj_p->goto_ts).string() << std::endl
00077 << "By-Frame Go:" << subobj_p->frame_go << " " << subobj_p->frame_objname << std::endl;
00078 return RTDBObj::dump() + ostr.str();
00079 };
00080 };
00081
00082 typedef RTDBObj_T < kogmo_rtdb_subobj_c3_playerctrl_t, KOGMO_RTDB_OBJTYPE_C3_PLAYERCTRL, RTDBObj > C3_PlayerCtrl_T;
00083 class C3_PlayerCtrlConvenient : public C3_PlayerCtrl
00084 {
00085 public:
00086 C3_PlayerCtrlConvenient(class RTDBConn& DBC, const char* name = "playerctrl") : C3_PlayerCtrl (DBC, name)
00087 {
00088 }
00089 void Update (void)
00090 {
00091 RTDBSearch();
00092 RTDBRead();
00093
00094 subobj_p->goto_ts = 0;
00095 subobj_p->frame_go = 0;
00096 }
00097 void Pause ( bool pause = 1 )
00098 {
00099 Update();
00100 subobj_p->flags.pause = pause;
00101 RTDBWrite();
00102 }
00103 void Speed ( float speed )
00104 {
00105 Update();
00106 subobj_p->speed = speed;
00107 RTDBWrite();
00108 }
00109 void ScanTo ( Timestamp ts, bool pause = 1 )
00110 {
00111 Update();
00112 subobj_p->goto_ts = ts;
00113 subobj_p->flags.scan = 1;
00114 subobj_p->flags.pause = pause;
00115 subobj_p->flags.loop = 1;
00116 subobj_p->flags.keepcreated = 1;
00117 RTDBWrite();
00118 }
00119 void JumpTo ( Timestamp ts, bool pause = 1 )
00120 {
00121 Update();
00122 subobj_p->goto_ts = ts;
00123 subobj_p->flags.scan = 0;
00124 subobj_p->flags.pause = pause;
00125 subobj_p->flags.loop = 1;
00126 subobj_p->flags.keepcreated = 1;
00127 RTDBWrite();
00128 }
00129 void FrameGo ( int count, const std::string name = "", bool pause = 1)
00130 {
00131 Update();
00132 if ( name.length() )
00133 {
00134 strncpy (subobj_p->frame_objname, name.c_str(), KOGMO_RTDB_OBJMETA_NAME_MAXLEN);
00135 subobj_p->frame_objname[KOGMO_RTDB_OBJMETA_NAME_MAXLEN-1] = '\0';
00136 }
00137 subobj_p->frame_go = count;
00138 subobj_p->flags.pause = pause;
00139 RTDBWrite();
00140 }
00141 void Loop ( Timestamp start, Timestamp end )
00142 {
00143 Update();
00144 subobj_p->begin_ts = start;
00145 subobj_p->end_ts = end;
00146 subobj_p->flags.loop = 1;
00147 subobj_p->flags.keepcreated = 1;
00148 RTDBWrite();
00149 }
00150 Timestamp currPlayTime (void)
00151 {
00152 RTDBConn DBC(getDBC());
00153 C3_PlayerStat Stat(DBC);
00154 Stat.RTDBSearch("playerstat");
00155 Stat.RTDBRead();
00156 return Stat.subobj_p->current_ts;
00157 }
00158 };
00159
00160 typedef RTDBObj_T < kogmo_rtdb_subobj_c3_recorderstat_t, KOGMO_RTDB_OBJTYPE_C3_RECORDERSTAT, RTDBObj > C3_RecorderStat_T;
00161 class C3_RecorderStat : public C3_RecorderStat_T
00162 {
00163 public:
00164 C3_RecorderStat(class RTDBConn& DBC, const char* name = "") : C3_RecorderStat_T (DBC, name)
00165 {
00166 }
00167 std::string dump (void) const
00168 {
00169 std::ostringstream ostr;
00170 ostr << "* Recorder Status :" << std::endl;
00171 if ( subobj_p -> begin_ts == 0 || objbase_p -> committed_ts == 0 || subobj_p -> begin_ts == objbase_p -> committed_ts )
00172 {
00173 ostr << "(not running)" << std::endl;
00174 }
00175 else
00176 {
00177 float runTime= kogmo_timestamp_diff_secs ( subobj_p -> begin_ts, objbase_p -> committed_ts );
00178 char text[100];
00179 snprintf(text,sizeof(text),
00180 "%.3f MB %i / %i Ev in %.2f secs (%.3f MB/s %.3f kEv/s) %i %s",
00181 (double)(subobj_p -> bytes_written)/1024/1024,
00182 subobj_p -> events_written, subobj_p -> events_total,
00183 runTime,
00184 (double)(subobj_p -> bytes_written)/1024/1024 / runTime,
00185 (double)(subobj_p -> events_written)/1000 / runTime,
00186 subobj_p -> events_lost,
00187 subobj_p -> events_lost > 0 ? "LOST!" : "lost");
00188 ostr << text;
00189 }
00190 return RTDBObj::dump() + ostr.str();
00191 };
00192 };
00193
00194 class C3_RecorderStatConvenient : public C3_RecorderStat
00195 {
00196 kogmo_timestamp_t last_ts;
00197 uint64_t last_bytes_written;
00198 uint32_t last_events_written;
00199 uint32_t last_events_total;
00200 uint32_t last_events_lost;
00201 public:
00202 C3_RecorderStatConvenient(class RTDBConn& DBC, const char* name = "recorderstat") : C3_RecorderStat (DBC, name)
00203 {
00204 last_ts=0;
00205 last_bytes_written=0;
00206 last_events_written=0;
00207 last_events_total=0;
00208 last_events_lost=0;
00209 }
00210 void Update (void)
00211 {
00212 try {
00213 last_ts = objbase_p -> committed_ts;
00214 last_bytes_written = subobj_p -> bytes_written;
00215 last_events_written = subobj_p -> events_written;
00216 last_events_total = subobj_p -> events_total;
00217 last_events_lost = subobj_p -> events_lost;
00218 RTDBRead();
00219 } catch (DBError err) {
00220 last_ts=0;
00221 last_bytes_written=0;
00222 last_events_written=0;
00223 last_events_total=0;
00224 last_events_lost=0;
00225 RTDBSearch();
00226 RTDBRead();
00227 }
00228 }
00229 float runTime (void) const
00230 {
00231 if ( subobj_p -> begin_ts == 0 || objbase_p -> committed_ts == 0)
00232 return 0;
00233 return kogmo_timestamp_diff_secs ( subobj_p -> begin_ts, objbase_p -> committed_ts );
00234 }
00235 int lagBuf (void) const
00236 {
00237 return subobj_p -> event_buflen - subobj_p -> event_buffree;
00238 }
00239 float lagTime (void) const
00240 {
00241 return kogmo_timestamp_diff_secs ( objbase_p -> data_ts, objbase_p -> committed_ts);
00242 }
00243
00244 float deltaTime (void) const
00245 {
00246 if ( last_ts == 0 || objbase_p -> committed_ts == 0)
00247 return 0;
00248 return kogmo_timestamp_diff_secs ( last_ts, objbase_p -> committed_ts );
00249 }
00250
00251 std::string currInfo (void) const
00252 {
00253 if ( ! deltaTime() )
00254 return "(no current info)";
00255 char text[100];
00256 snprintf(text,sizeof(text),
00257 "%.3f MB/s %.1f Ev/s (Lag: %.3f ms %i Ev) %i Ev %s",
00258 (double)(subobj_p -> bytes_written - last_bytes_written)/1024/1024 / deltaTime(),
00259 (double)(subobj_p -> events_written - last_events_written) / deltaTime(),
00260 lagTime() * 1000, lagBuf(), subobj_p -> events_lost - last_events_lost,
00261 subobj_p -> events_lost - last_events_lost > 0 ? "LOST!" : "lost");
00262 return text;
00263 }
00264
00265 std::string totalInfo (void) const
00266 {
00267 if ( ! runTime() )
00268 return "(no total info)";
00269 char text[100];
00270 snprintf(text,sizeof(text),
00271 "%.3f MB %i / %i Ev in %.2f secs (%.3f MB/s %.3f kEv/s) %i %s",
00272 (double)(subobj_p -> bytes_written)/1024/1024,
00273 subobj_p -> events_written, subobj_p -> events_total,
00274 runTime(),
00275 (double)(subobj_p -> bytes_written)/1024/1024 / runTime(),
00276 (double)(subobj_p -> events_written)/1000 / runTime(),
00277 subobj_p -> events_lost,
00278 subobj_p -> events_lost > 0 ? "LOST!" : "lost");
00279 return text;
00280 }
00281
00282 std::string dump (void) const
00283 {
00284 return RTDBObj::dump() + totalInfo() + currInfo();
00285 };
00286 };
00287
00288
00289
00290
00291
00292
00293
00294
00295
00296
00297
00298 class C3_RTDB : public RTDBObj
00299 {
00300 protected:
00301 kogmo_rtdb_subobj_c3_rtdb_t *objrtdb_p;
00302 C3_RTDB ( const C3_RTDB& );
00303 public:
00304 C3_RTDB (class RTDBConn& DBC,
00305 const char* name = "",
00306 const int& otype = KOGMO_RTDB_OBJTYPE_C3_RTDB,
00307 const int32_t& child_size = 0, char** child_dataptr = NULL)
00308 : RTDBObj (DBC, name, otype, sizeof(kogmo_rtdb_subobj_c3_rtdb_t) +
00309 child_size, (char**)&objrtdb_p)
00310 {
00311
00312 if ( child_size && child_dataptr != NULL )
00313 *child_dataptr = (char*)objrtdb_p + sizeof (kogmo_rtdb_subobj_c3_rtdb_t);
00314 };
00315
00316 Timestamp getStartedTimestamp () const
00317 {
00318 return objrtdb_p->started_ts;
00319 }
00320
00321 std::string getDBHost () const
00322 {
00323 return std::string (objrtdb_p->dbhost);
00324 }
00325
00326 uint32_t getVersionRevision () const
00327 {
00328 return objrtdb_p->version_rev;
00329 }
00330
00331 std::string getVersionDate () const
00332 {
00333 return std::string (objrtdb_p->version_date);
00334 }
00335
00336 std::string getVersionID () const
00337 {
00338 return std::string (objrtdb_p->version_id);
00339 }
00340
00341 uint32_t getObjectsMax () const
00342 {
00343 return objrtdb_p->objects_max;
00344 }
00345
00346 uint32_t getObjectsFree () const
00347 {
00348 return objrtdb_p->objects_free;
00349 }
00350
00351 uint32_t getProcessesMax () const
00352 {
00353 return objrtdb_p->processes_max;
00354 }
00355
00356 uint32_t getProcessesFree () const
00357 {
00358 return objrtdb_p->processes_free;
00359 }
00360
00361 uint32_t getMemoryMax () const
00362 {
00363 return objrtdb_p->memory_max;
00364 }
00365
00366 uint32_t getMemoryFree () const
00367 {
00368 return objrtdb_p->memory_free;
00369 }
00370
00371 std::string dump (void) const
00372 {
00373 std::ostringstream ostr;
00374 ostr << "* RTDB Runtime Information:" << std::endl
00375 << "VersionID: " << getVersionID() << std::endl
00376 << "Revision of Database: " << getVersionRevision() << " (" << getVersionDate() << ")" << std::endl
00377 << "Database Host: " << getDBHost() << std::endl
00378 << "Timestamp of Database Start: " << getStartedTimestamp() << std::endl
00379 << "Database Runtime: " << (float)((getCommittedTimestamp()-getStartedTimestamp())/60) << " minutes"<< std::endl
00380 << "Timestamp of this Information: " << getCommittedTimestamp() << std::endl
00381 << "Last Update of this Information: " << (float)((Timestamp().now()-getCommittedTimestamp())) << " seconds"<< std::endl
00382 << "Memory free: " << getMemoryFree() << "/" << getMemoryMax() << std::endl
00383 << "Objects free: " << getObjectsFree() << "/" << getObjectsMax() << std::endl
00384 << "Processes free: " << getProcessesFree() << "/" << getProcessesMax() << std::endl;
00385 return RTDBObj::dump() + ostr.str();
00386 };
00387 };
00388
00389
00390
00391 class C3_Process : public RTDBObj
00392 {
00393 protected:
00394 kogmo_rtdb_subobj_c3_process_t *objprocess_p;
00395 public:
00396 C3_Process (class RTDBConn& DBC,
00397 const char* name = "" )
00398 : RTDBObj (DBC, name, KOGMO_RTDB_OBJTYPE_C3_PROCESS,
00399 sizeof(kogmo_rtdb_subobj_c3_process_t), (char**)&objprocess_p)
00400 {
00401 if ( name != NULL && name[0] != '\0' )
00402 {
00403
00404
00405
00406
00407 RTDBSearchWait(name);
00408 RTDBReadWaitNext();
00409 }
00410 };
00411
00412 void RTDBWrite (int32_t size = 0, Timestamp ts = 0)
00413 {
00414 throw("Please do not manually write Process Objects!");
00415 int __attribute__ ((unused)) dummy = ts / size;
00416 }
00417
00418 kogmo_rtdb_objid_t getProcOID () const
00419 {
00420 return objprocess_p->proc_oid;
00421 }
00422
00423 int getPID () const
00424 {
00425 return objprocess_p->pid;
00426 }
00427
00428 int getUID () const
00429 {
00430 return objprocess_p->uid;
00431 }
00432
00433 int getStatus () const
00434 {
00435 return objprocess_p->status;
00436 }
00437
00438 const char *getStatusTxt () const
00439 {
00440 switch (objprocess_p->status)
00441 {
00442 case KOGMO_RTDB_PROCSTATUS_UNKNOWN: return "unknown"; break;
00443 case KOGMO_RTDB_PROCSTATUS_CYCLEDONE: return "cycle done"; break;
00444 case KOGMO_RTDB_PROCSTATUS_BUSY: return "busy"; break;
00445 case KOGMO_RTDB_PROCSTATUS_WAITING: return "waiting"; break;
00446 case KOGMO_RTDB_PROCSTATUS_FAILURE: return "failure"; break;
00447 }
00448 return "? (unknown status id)";
00449 }
00450
00451 char *getStatusMsg () const
00452 {
00453 return objprocess_p->statusmsg;
00454 }
00455
00456 std::string getStatusInfo () const
00457 {
00458 return std::string(getStatusTxt()) + " (" + std::string(getStatusMsg()) + ")";
00459 }
00460
00461 #ifdef HAVE_DBC_SetStatus
00462
00463
00464 void WaitSuccessiveCycleDone ()
00465 {
00466 RTDBConn DBC(db_h);
00467 std::ostringstream info;
00468 info << "waiting for process " << getName() << " (" << getProcOID() << ")";
00469 DBC.SetStatus_Waiting(info.str().c_str());
00470 do
00471 {
00472 try
00473 {
00474 RTDBReadWaitSuccessor();
00475 }
00476 catch(DBError err)
00477 {
00478 RTDBRead();
00479 }
00480 }
00481 while ( getStatus() != KOGMO_RTDB_PROCSTATUS_CYCLEDONE );
00482 DBC.SetStatus_Busy();
00483 }
00484
00485
00486 void WaitCycleDone ()
00487 {
00488 WaitSuccessiveCycleDone();
00489 }
00490 #endif
00491
00492 std::string dump (void) const
00493 {
00494 std::ostringstream ostr;
00495 ostr << "* Process Information:" << std::endl
00496 << "Process-OID: " << objprocess_p->proc_oid << std::endl
00497 << "PID: " << objprocess_p->pid << std::endl
00498 << "TID: " << objprocess_p->tid << std::endl
00499 << "Status: " << std::string(getStatusTxt()) << " (" << objprocess_p->status << ")" << std::endl
00500 << "Status Message: " << std::string(objprocess_p->statusmsg) << std::endl
00501 << "Version: " << objprocess_p->version << std::endl
00502 << "User-ID: " << objprocess_p->uid << std::endl;
00503 return RTDBObj::dump() + ostr.str();
00504 };
00505 };
00506
00507
00508
00509
00510
00511
00512
00513 typedef RTDBObj_T < kogmo_rtdb_subobj_c3_text_t, KOGMO_RTDB_OBJTYPE_C3_TEXT > C3_Text_T;
00514 class C3_Text : public C3_Text_T
00515 {
00516 public:
00517 C3_Text(class RTDBConn& DBC, const char* name = "") : C3_Text_T (DBC, name)
00518 {
00519 setMinSize( - (int)sizeof(char) * C3_TEXT_MAXCHARS );
00520 deleteText();
00521 }
00522
00523 void deleteText (void)
00524 {
00525 setSize( getMinSize() );
00526 }
00527
00528 int getLength (void) const
00529 {
00530 return getSize()-getMinSize();
00531 }
00532
00533 void addText (std::string text)
00534 {
00535 if ( getLength() + text.length() >= C3_TEXT_MAXCHARS )
00536 throw DBError("Text too long, try to increase C3_TEXT_MAXCHARS");
00537 strncpy (&subobj_p->data[getLength()], text.c_str(), C3_TEXT_MAXCHARS - getLength() );
00538 setSize( getMinSize() + getLength() + text.length() );
00539 };
00540
00541 void setText (std::string text)
00542 {
00543 deleteText();
00544 addText(text);
00545 };
00546
00547 std::string getText () const
00548 {
00549 std::string text = "";
00550 if ( getLength() > 0 )
00551 text.append ( subobj_p->data, getLength() );
00552 return text;
00553 };
00554
00555 std::string dump(void) const
00556 {
00557 std::ostringstream ostr;
00558 ostr << "* Text:" << std::endl
00559 << getText() << std::endl;
00560 return RTDBObj::dump() + ostr.str();
00561 };
00562 };
00563
00564
00565
00566 typedef RTDBObj_T < kogmo_rtdb_subobj_c3_ints256_t, KOGMO_RTDB_OBJTYPE_C3_INTS > C3_Ints_T;
00567 class C3_Ints : public C3_Ints_T
00568 {
00569 public:
00570 C3_Ints(class RTDBConn& DBC, const char* name = "") : C3_Ints_T (DBC, name)
00571 {
00572 }
00573
00574 int getLength (void) const
00575 {
00576 return 256;
00577 }
00578
00579 void setInt (const int& n, const int& i)
00580 {
00581 if ( n >= getLength() )
00582 throw DBError(-KOGMO_RTDB_ERR_INVALID);
00583 subobj_p->intval[n] = i;
00584 }
00585
00586 int getInt (const int& n) const
00587 {
00588 if ( n >= getLength() )
00589 throw DBError(-KOGMO_RTDB_ERR_INVALID);
00590 return subobj_p->intval[n];
00591 }
00592
00593 std::string dump (void) const
00594 {
00595 std::ostringstream ostr;
00596 ostr << "* Integer Values:" << std::endl;
00597 for (int i=0; i < getLength(); i++)
00598 {
00599 ostr << i << ": " << getInt(i) << std::endl;
00600 }
00601 return RTDBObj::dump() + ostr.str();
00602 };
00603 };
00604
00605
00606
00607
00608 template < int width = 1024, int height = 768, int channels = 1, int bits=8 > class A2_Image
00609 : public RTDBObj_T < kogmo_rtdb_subobj_a2_image_t, KOGMO_RTDB_OBJTYPE_A2_IMAGE, RTDBObj, width*height*channels*bits/8 >
00610 {
00611 private:
00612 bool use_read_ptr;
00613 kogmo_rtdb_obj_a2_image_t *read_ptr;
00614 Timestamp read_ptr_ts;
00615 public:
00616 A2_Image(class RTDBConn& DBC, const char* name = "")
00617 : RTDBObj_T < kogmo_rtdb_subobj_a2_image_t, KOGMO_RTDB_OBJTYPE_A2_IMAGE, RTDBObj, width*height*channels*bits/8 > (DBC, name)
00618 {
00619 this->subobj_p->width=width;
00620 this->subobj_p->height=height;
00621 this->subobj_p->channels=channels;
00622 this->subobj_p->colormodell=0;
00623 this->subobj_p->widthstep=abs(width)*channels*bits/8;
00624
00625 switch (bits)
00626 {
00627 case 16:
00628 this->subobj_p->depth=A2_IMAGE_DEPTH_16U;
00629 break;
00630 case 32:
00631 this->subobj_p->depth=A2_IMAGE_DEPTH_32F;
00632 break;
00633 case 8:
00634 default:
00635 this->subobj_p->depth=A2_IMAGE_DEPTH_8U;
00636 break;
00637 }
00638 use_read_ptr = false;
00639 read_ptr = NULL;
00640 read_ptr_ts = 0;
00641 }
00642 unsigned char * getData(Timestamp committed_ts = 0)
00643 {
00644 if ( !use_read_ptr )
00645 return &this->subobj_p->data[0];
00646 else
00647 {
00648 if (!committed_ts)
00649 committed_ts = this->getCommittedTimestamp();
00650 if ( read_ptr_ts != committed_ts )
00651 {
00652 kogmo_rtdb_objsize_t osize;
00653 osize = kogmo_rtdb_obj_readdata_ptr (this->db_h, this->objinfo_p -> oid, committed_ts,
00654 &read_ptr);
00655 if ( osize < *(this->objsize_min_p) )
00656 throw DBError(osize);
00657 if ( read_ptr->base.committed_ts != (kogmo_timestamp_t) committed_ts )
00658 throw DBError(-KOGMO_RTDB_ERR_HISTWRAP);
00659 read_ptr_ts = this->getCommittedTimestamp();
00660 }
00661 return read_ptr->image.data;
00662 }
00663 }
00664 bool isDataValid( Timestamp committed_ts = 0 )
00665 {
00666 if ( !use_read_ptr )
00667 return true;
00668 read_ptr_ts = 0;
00669 try {
00670 getData(committed_ts);
00671 return true;
00672 } catch(DBError err) {
00673 return false;
00674 }
00675 }
00676 void setPointerRead(bool yes = true)
00677 {
00678 use_read_ptr = yes;
00679 if ( use_read_ptr )
00680 this->setMinSize( sizeof(kogmo_rtdb_obj_a2_image_t) );
00681 else
00682 this->setMinSize( this->getMaxSize() );
00683 }
00684 int getWidth(void)
00685 {
00686 return abs(this->subobj_p->width);
00687 }
00688 int getHeight(void)
00689 {
00690 return abs(this->subobj_p->height);
00691 }
00692 int getChannels(void)
00693 {
00694 return this->subobj_p->channels;
00695 }
00696 int getDepth(void)
00697 {
00698 return this->subobj_p->depth;
00699 }
00700 int getWidthstep(void)
00701 {
00702 return this->subobj_p->widthstep;
00703 }
00704 int getColormodel(void)
00705 {
00706 return this->subobj_p->colormodell;
00707 }
00708 int calcImgSize(void)
00709 {
00710 return getWidthstep() * getHeight();
00711 }
00712 std::string dump(void) const
00713 {
00714 std::ostringstream ostr;
00715 const char *colormodels[]={"RGB/Grayscale", "YUV411", "YUV422", "YUV444", "?", "?", "?", "?", "?", "?", "?", "?", "?", "?", "?", "?", "RGB-JPEG"};
00716 ostr << "* Image:" << std::endl
00717 << "Size (width x height): " << this->subobj_p->width << " x " << this->subobj_p->height << " Pixel" << std::endl
00718 << "Width-Step: " << this->subobj_p->widthstep << std::endl
00719 << "Color Channels [1 for greyscale, 3 for color]: " << this->subobj_p->channels << std::endl
00720
00721 << "Color Modell: " << ( this->subobj_p->colormodell < (signed)(sizeof(colormodels)/sizeof(char*)) && this->subobj_p->colormodell >= 0 ? colormodels[this->subobj_p->colormodell] : "?" ) << " (" << this->subobj_p->colormodell << ")" << std::endl
00722 << "Depth: " << this->subobj_p->depth << " Bits/Pixel" <<std::endl;
00723 return RTDBObj::dump() + ostr.str();
00724 };
00725 };
00726
00727
00728
00729 typedef A2_Image < 640, 480, 1 > A2_Image_Gray640x480;
00730 typedef A2_Image < 1024, 768, 1 > A2_Image_Gray1024x768;
00731
00732 typedef A2_Image < 768, 400, 1 > A2_Image_Gray768x400;
00733 typedef A2_Image < 748, 400, 1 > A2_Image_Gray748x400;
00734
00735 typedef A2_Image < 640, 480, 3 > A2_Image_RGB640x480;
00736 typedef A2_Image < 1024, 768, 3 > A2_Image_RGB1024x768;
00737
00738 typedef A2_Image < 640, 480, 1, 16 > A2_Image_Gray640x480x16;
00739 typedef A2_Image < 640, 480, 3, 16 > A2_Image_RGB640x480x16;
00740 typedef A2_Image < 640, 480, 1, 32 > A2_Image_Gray640x480x32;
00741 typedef A2_Image < 640, 480, 3, 32 > A2_Image_RGB640x480x32;
00742
00743
00744 typedef A2_Image_RGB1024x768 A2_BiggestImage;
00745
00746 class A2_AnyImage : public A2_BiggestImage
00747 {
00748 public:
00749 A2_AnyImage(class RTDBConn& DBC, const char* name = "") : A2_BiggestImage (DBC, name)
00750 {
00751 setMinSize( - calcImgSize() );
00752 }
00753 };
00754
00755
00756
00757
00758 };
00759
00760 #endif
00761
00762
00763
00764