void CCameraThread::ThreadFunc(void *pMsg)
{
int calculateOffset(IplImage *, IplImage *, double *);
IplImage *srcImage = NULL, *dstImage;
double scale;
srcImage = cvQueryFrame(m_pCamera);
if (!srcImage) return;
dstImage = cvCloneImage(srcImage);
if (m_bAdjust) {
int res = calculateOffset(srcImage, dstImage, &scale);
if(res == 0){
AdjustMotor(scale);
}
}
m_cLineAdj->drawToDC(dstImage, m_iIndex);
cvReleaseImage(&dstImage);
/*
double x = cvGetCaptureProperty(m_pCamera, CV_CAP_PROP_FPS);
double y = cvGetCaptureProperty(m_pCamera, CV_CAP_PROP_FRAME_WIDTH);
double z = cvGetCaptureProperty(m_pCamera, CV_CAP_PROP_FRAME_HEIGHT);
int w = srcImage->width;
int h = srcImage->height;
*/
}
void QgsMapToolOffsetCurve::canvasMoveEvent( QgsMapMouseEvent *e )
{
if ( mOriginalGeometry.isNull() || !mRubberBand )
{
return;
}
mGeometryModified = true;
QgsPointXY mapPoint = e->snapPoint();
mSnapIndicator->setMatch( e->mapPointMatch() );
double offset = calculateOffset( mapPoint );
if ( mUserInputWidget )
{
disconnect( mUserInputWidget, &QgsOffsetUserWidget::offsetChanged, this, &QgsMapToolOffsetCurve::updateGeometryAndRubberBand );
mUserInputWidget->setOffset( offset );
connect( mUserInputWidget, &QgsOffsetUserWidget::offsetChanged, this, &QgsMapToolOffsetCurve::updateGeometryAndRubberBand );
mUserInputWidget->setFocus( Qt::TabFocusReason );
mUserInputWidget->editor()->selectAll();
}
//create offset geometry using geos
updateGeometryAndRubberBand( offset );
}
// ---------------------------------------------------------------------------------------------------------------------------------------------------
//
void CommonTimeBase::newReading( int _serverTimeMillis, int _pingMillis )
{
// bail if the ping round trip is just too long to be reliable
if( _pingMillis > MAX_CONSIDERED_PING_TIME_MILLIS )
{
return;
}
pingMillis.insert( _pingMillis );
if( pingMillis.size() > PING_AMOUNT_TO_KEEP )
{
pingMillis.erase( --pingMillis.end() );
}
/*
// debug print the multiset
cout << "--------------------------------------------------------" << endl;
multiset<int>::iterator tmpIt;
for ( tmpIt = pingMillis.begin(); tmpIt != pingMillis.end(); tmpIt++)
{
cout << *tmpIt << endl;
}
cout << "--------------------------------------------------------" << endl;
*/
calculateOffset( _serverTimeMillis );
// If we are still in the initialisation phase, be more aggressive in how often we send out pings
if( pingMillis.size() < PING_AMOUNT_TO_KEEP )
{
millisBetweenPings = INITIALISATION_PING_DELAY_MILLIS;
}
else
{
millisBetweenPings = POST_INITIALISATION_PING_DELAY_MILLIS;
}
}
bool RS_ActionPolylineEquidistant::makeContour() {
if (container==NULL) {
RS_DEBUG->print("RS_ActionPolylineEquidistant::makeContour: no valid container",
RS_Debug::D_WARNING);
return false;
}
RS_Polyline* originalPolyline = (RS_Polyline*)originalEntity;
//create a list of entities to offset without length = 0
QList<RS_Entity*> entities;
for (RS_Entity* en=originalPolyline->firstEntity(); en!=NULL; en=originalPolyline->nextEntity()) {
if (en->getLength() > 1.0e-12)
entities.append(en);
}
if (entities.isEmpty()) {
return false;
}
if (document!=NULL) {
document->startUndoCycle();
}
double neg = 1.0;
if(bRightSide)
neg = -1.0;
// Create new helper entities
RS_Line line1(NULL, RS_LineData(RS_Vector(true), RS_Vector(true)));//current line
RS_Line lineFirst(NULL, RS_LineData(RS_Vector(true), RS_Vector(true)));//previous line
RS_Arc arc1(NULL, RS_ArcData(RS_Vector(true), 0,0,0,false));//current arc
RS_Arc arcFirst(NULL, RS_ArcData(RS_Vector(true), 0,0,0,false));//previous arc
for (int num=1; num<=number || (number==0 && num<=1); num++) {
RS_Polyline* newPolyline = new RS_Polyline(container);
newPolyline->setLayer(((RS_Polyline*)originalEntity)->getLayer());
newPolyline->setPen(((RS_Polyline*)originalEntity)->getPen());
bool first = true;
bool closed = originalPolyline->isClosed();
double bulge = 0.0;
RS_Entity* en;
RS_Entity* prevEntity = entities.last();
RS_Entity* currEntity;
for (int i = 0; i < entities.size(); ++i) {
en = entities.at(i);
RS_Vector v(false);
if (en->rtti()==RS2::EntityArc) {
currEntity = &arc1;
calculateOffset(currEntity, en, dist*num*neg);
bulge = arc1.getBulge();
} else {
currEntity = &line1;
bulge = 0.0;
calculateOffset(currEntity, en, dist*num*neg);
}
if (first) {
if (closed) {
if (prevEntity->rtti()==RS2::EntityArc) {
prevEntity = calculateOffset(&arcFirst, prevEntity, dist*num*neg);
} else {
prevEntity = calculateOffset(&lineFirst, prevEntity, dist*num*neg);
}
v = calculateIntersection(prevEntity, currEntity);
}
if (!v.valid) {
v = currEntity->getStartpoint();
closed = false;
} else if (currEntity->rtti()==RS2::EntityArc) {
//update bulge
arc1.setAngle1(arc1.getCenter().angleTo(v));
arc1.calculateEndpoints();
bulge = arc1.getBulge();
}
first = false;
if (!prevEntity) break; //prevent crash if not exist offset for prevEntity
} else {
v = calculateIntersection(prevEntity, currEntity);
if (!v.valid) {
v= prevEntity->getEndpoint();
double dess = currEntity->getStartpoint().distanceTo(prevEntity->getEndpoint());
if (dess > 1.0e-12) {
newPolyline->addVertex(v, bulge);
prevEntity = NULL;
break;
}
}
double startAngle = prevEntity->getStartpoint().angleTo(prevEntity->getEndpoint());
if (prevEntity->rtti()==RS2::EntityArc) {
arcFirst.setAngle2(arcFirst.getCenter().angleTo(v));
arcFirst.calculateEndpoints();
newPolyline->setNextBulge(arcFirst.getBulge());
}
//check if the entity are reverted
if (abs (prevEntity->getStartpoint().angleTo(prevEntity->getEndpoint())- startAngle) > 0.785) {
prevEntity = newPolyline->lastEntity();
RS_Vector v0 = calculateIntersection(prevEntity, currEntity);
if (prevEntity->rtti()==RS2::EntityArc) {
((RS_Arc*)prevEntity)->setAngle2(arcFirst.getCenter().angleTo(v0));
((RS_Arc*)prevEntity)->calculateEndpoints();
newPolyline->setNextBulge( ((RS_Arc*)prevEntity)->getBulge() );
} else {
((RS_Line*)prevEntity)->setEndpoint(v0);
newPolyline->setNextBulge( 0.0 );
}
newPolyline->setEndpoint(v0);
}
if (currEntity->rtti()==RS2::EntityArc) {
arc1.setAngle1(arc1.getCenter().angleTo(v));
arc1.calculateEndpoints();
bulge = arc1.getBulge();
} else
bulge = 0.0;
}
if (prevEntity) {
newPolyline->addVertex(v, bulge, false);
if (currEntity->rtti()==RS2::EntityArc) {
arcFirst.setData(arc1.getData());
arcFirst.calculateEndpoints();
prevEntity = &arcFirst;
} else {
lineFirst.setStartpoint(line1.getStartpoint());
lineFirst.setEndpoint(line1.getEndpoint());
prevEntity = &lineFirst;
}
}
}
//properly terminated, check closed
if (prevEntity) {
if (closed) {
if (currEntity->rtti()==RS2::EntityArc) {
arc1.setAngle2(arc1.getCenter().angleTo(newPolyline->getStartpoint()));
arc1.calculateEndpoints();
newPolyline->setNextBulge(arc1.getBulge());
bulge = arc1.getBulge();
}
newPolyline->setClosed(true, bulge);
} else {
newPolyline->addVertex(currEntity->getEndpoint(), bulge);
}
}
if (!newPolyline->isEmpty()) {
container->addEntity(newPolyline);
document->addUndoable(newPolyline);
}
}
if (document!=NULL) {
document->endUndoCycle();
}
if (graphicView!=NULL) {
graphicView->redraw();
}
return true;
}
void RulerLabel::draw(int sel)
{
if (drawMode == DRAW_HIDDEN) return;
if (vertex1.isSet())
{
vec2d startPnt = vertex1.pos2d();
vec2d endPnt = cursor;
if (vertex2.isSet())
{
vec3d start3d(0,0,0);
vec3d end3d(0,0,0);
getVertexPoints(&start3d, &end3d);
startPnt = vertex1.viewProject( start3d );
endPnt = vertex2.viewProject( end3d );
}
//==== Calculate Distance ====//
calculateDistance();
Stringc label;
if (vertex2.isSet())
{
char str[255];
char fmt[255];
sprintf(fmt, "%%0.%df %%s", precision);
sprintf(str, fmt, rulerDistance, unitString.get_char_star());
label = str;
}
else
{
label = getName();
}
if (sel)
glColor3ub(255, 0, 0);
else
glColor3ub((int)color.x(), (int)color.y(), (int)color.z());
//==== Draw Points ====//
if (drawMode == DRAW_HIGHLIGHT)
{
glPointSize(sel ? 7.0f : 6.0f);
glBegin(GL_POINTS);
glVertex2d(startPnt.x(), startPnt.y());
glVertex2d(endPnt.x(), endPnt.y());
glEnd();
}
//==== Calculate Offset ====//
if (attachState == VERTEX2_SET)
calculateOffset();
vec2d deltavec = startPnt - endPnt;
vec2d offset(deltavec.y(), -deltavec.x());
offset.normalize();
vec2d startOff = startPnt + offset * rulerOffset * viewScale;
vec2d endOff = endPnt + offset * rulerOffset * viewScale;
//==== Draw Lines ====//
glLineWidth(sel ? 2.0f : 1.0f);
glBegin(GL_LINE_STRIP);
glVertex2d(startPnt.x(), startPnt.y());
glVertex2d(startOff.x(), startOff.y());
glVertex2d(endOff.x(), endOff.y());
glVertex2d(endPnt.x(), endPnt.y());
glEnd();
//==== Draw Text ====//
vec2d vc = (startOff + endOff) * 0.5;
double ang = PI/2.0;
if (deltavec.x() > 0.0001 || deltavec.x() < -0.0001) // ~!= 0
ang = atan( (deltavec.y()) / (deltavec.x()) );
glColor3ub((int)color.x(), (int)color.y(), (int)color.z());
glPushMatrix();
{
glTranslated(vc.x(), vc.y(), 0);
glRotatef((float)RAD2DEG(ang), 0,0,1);
glEnable(GL_TEXTURE_2D);
if ( font )
drawString(font, textSize * (float)sqrt(viewScale), label, 0,0, (float)textOffset, 0.7f);
glDisable(GL_TEXTURE_2D);
}
glPopMatrix();
}
}
void RulerLabel::setOffset(float mx, float my)
{
calculateOffset();
}
void QgsMapToolOffsetCurve::canvasReleaseEvent( QgsMapMouseEvent *e )
{
mCtrlHeldOnFirstClick = false;
if ( e->button() == Qt::RightButton )
{
cancel();
return;
}
if ( mOriginalGeometry.isNull() )
{
// first click, get feature to modify
deleteRubberBandAndGeometry();
mGeometryModified = false;
QgsPointLocator::Match match = mCanvas->snappingUtils()->snapToCurrentLayer( e->pos(),
QgsPointLocator::Types( QgsPointLocator::Edge | QgsPointLocator::Area ) );
if ( ( match.hasEdge() || match.hasArea() ) && match.layer() )
{
mLayer = match.layer();
QgsFeature fet;
if ( match.layer()->getFeatures( QgsFeatureRequest( match.featureId() ) ).nextFeature( fet ) )
{
mCtrlHeldOnFirstClick = ( e->modifiers() & Qt::ControlModifier ); //no geometry modification if ctrl is pressed
prepareGeometry( match, fet );
mRubberBand = createRubberBand();
if ( mRubberBand )
{
mRubberBand->setToGeometry( mManipulatedGeometry, match.layer() );
}
mModifiedFeature = fet.id();
createUserInputWidget();
bool hasZ = QgsWkbTypes::hasZ( mLayer->wkbType() );
bool hasM = QgsWkbTypes::hasZ( mLayer->wkbType() );
if ( hasZ || hasM )
{
emit messageEmitted( QStringLiteral( "layer %1 has %2%3%4 geometry. %2%3%4 values be set to 0 when using offset tool." )
.arg( mLayer->name() )
.arg( hasZ ? "Z" : "" )
.arg( hasZ && hasM ? "/" : "" )
.arg( hasM ? "M" : "" )
, Qgis::Warning );
}
}
}
if ( mOriginalGeometry.isNull() )
{
emit messageEmitted( tr( "Could not find a nearby feature in any vector layer." ) );
cancel();
notifyNotVectorLayer();
}
}
else
{
// second click - apply changes
double offset = calculateOffset( e->snapPoint() );
applyOffset( offset, e->modifiers() );
}
}
cue_t *cue_new(const char *file)
{
cue_t *r = (cue_t *) mc_malloc(sizeof(cue_t));
r->audio_file = NULL;
r->album_title = NULL;
r->album_performer = NULL;
r->album_composer = NULL;
r->genre = NULL;
r->cuefile = mystrdup(file);
r->count = 0;
r->entries = NULL;
r->_errno = 0;
FILE *f = fopen(file, "rt");
time_t _audio_mtime=0;
if (f == NULL) {
r->_errno = ENOFILECUE;
} else {
char *line;
char *image = NULL;
char *year = NULL;
cue_entry_t *entry = NULL;
int in_tracks = 0;
while ((line = readline(f)) != NULL) {
trim_replace(&line);
if (strcmp(line, "") != 0) {
if (!in_tracks) {
if (eq(line, "performer")) {
mc_free(r->album_performer);
r->album_performer = unquote(line, "performer");
} else if (eq(line, "title")) {
mc_free(r->album_title);
r->album_title = unquote(line, "title");
} else if (eq(line, "file")) {
mc_free(r->audio_file);
char *fl = getFilePart(line);
char *af = unquote(fl, "");
if (strlen(af) > 0) {
if (af[0] == '/') {
r->audio_file = af;
} else {
char *cf = mc_strdup(r->cuefile);
int ii;
for (ii = strlen(cf) - 1; ii >= 0 && cf[ii] != '/'; ii--) ;
if (ii >= 0) {
cf[ii] = '\0';
char *aaf = (char *)mc_malloc(strlen(cf) + strlen(af) + strlen("/") + 1);
sprintf(aaf, "%s/%s", cf, af);
r->audio_file = aaf;
mc_free(cf);
mc_free(af);
} else {
r->audio_file = af;
}
}
} else {
r->audio_file = af;
}
// We have a full path audio file now.
// get the mtime.
{
struct stat st;
stat(r->audio_file,&st);
_audio_mtime=st.st_mtime;
}
mc_free(fl);
} else if (eq(line, "rem")) {
if (eq(&line[3], "date")) {
mc_free(year);
year = unquote(&line[3], "date");
} else if (eq(&line[3], "image")) {
mc_free(image);
image = unquote(&line[3], "image");
} else if (eq(&line[3], "composer")) {
mc_free(r->album_composer);
r->album_performer = unquote(&line[3], "composer");
} else if (eq(&line[3], "genre")) {
mc_free(r->genre);
r->genre = unquote(&line[3], "genre");
}
} else if (eq(line, "track")) {
in_tracks = 1;
}
}
if (in_tracks) {
if (eq(line, "track")) {
log_debug2("track: entry=%p", entry);
if (entry != NULL) {
addEntry(r, entry);
}
entry = cue_entry_new(r);
entry->audio_mtime=_audio_mtime;
entry->year = mystrdup(year);
entry->performer = mystrdup(r->album_performer);
entry->composer = mystrdup(r->album_composer);
entry->piece = NULL;
log_debug2("track: created new entry %p", entry);
} else if (eq(line, "title")) {
mc_free(entry->title);
entry->title = unquote(line, "title");
} else if (eq(line, "performer")) {
mc_free(entry->performer);
entry->performer = unquote(line, "performer");
} else if (eq(line, "index")) {
char *index = unquote(line, "index");
entry->begin_offset_in_ms = calculateOffset(index);
mc_free(index);
} else if (eq(line, "rem")) {
if (eq(&line[3], "composer")) {
mc_free(entry->composer);
entry->composer = unquote(&line[3], "composer");
} else if (eq(&line[3], "piece")) {
mc_free(entry->piece);
entry->piece = unquote(&line[3], "piece");
} else if (eq(&line[3], "year")) {
mc_free(year);
year = unquote(&line[3], "year");
mc_free(entry->year);
entry->year = mystrdup(year);
}
}
}
}
mc_free(line);
}
if (entry != NULL) {
addEntry(r, entry);
}
mc_free(year);
mc_free(image);
{
int i, N;
for (i = 0, N = r->count; i < N - 1; i++) {
r->entries[i]->end_offset_in_ms = r->entries[i + 1]->begin_offset_in_ms;
r->entries[i]->tracknr = i + 1;
}
r->entries[i]->tracknr = i + 1;
}
fclose(f);
}
return r;
}
