void SplineControl::controlPoint_FingerUp(ControlPoint &cp, const FingerEventArgs &e)
{
if(!controlPointContains(e))
{
for(vector<ControlPoint *>::iterator it = controlPoints.begin(); it != controlPoints.end(); it++)
{
ControlPoint *itCp = *it;
assert(itCp != NULL);
if(cp.getId() == itCp->getId())
{
controlPoints.erase(it);
break;
}
}
deleteInterfaceElement(&cp);
}
snapControlPoint(cp);
fullLengthDirty = true;
dirty = true;
splineDirty = true;
}
void OpacityTransferFunctionWidget::RestoreControlPoints(int number,
float max,
float* scalar,
float* opacity) {
// Temporary control point
ControlPoint tmp;
// Set number of control points
_numberOfControlPoints = number;
// Set maximum scalar value
_scalarMaximum = max;
// Clear all control points
_controlPoint.clear();
// Set each control point from arrays
for (int i = 0 ; i < number ; i++) {
tmp.SetScalar(scalar[i]);
tmp.SetOpacity(opacity[i]);
_controlPoint.push_back(tmp);
}
// Set focus point
_focusPoint = -1;
return;
}
void QnetSetAprioriDialog::fillLineEdits() {
QString id = m_points.at(0)->text();
ControlPoint *pt = m_qnetTool->controlNet()->GetPoint(id);
SurfacePoint sPt = pt->GetAprioriSurfacePoint();
vector<Distance> targetRadii = m_qnetTool->controlNet()->GetTargetRadii();
sPt.SetRadii(Distance(targetRadii[0]),
Distance(targetRadii[1]),
Distance(targetRadii[2]));
if (sPt.GetLatitude().degrees() != Null) {
aprioriLatEdit->setText(
QString::number(sPt.GetLatitude().degrees()));
}
if (sPt.GetLatSigmaDistance().meters() != Null) {
latSigmaEdit->setText(
QString::number(sPt.GetLatSigmaDistance().meters()));
}
if (sPt.GetLongitude().degrees() != Null) {
aprioriLonEdit->setText(
QString::number(sPt.GetLongitude().degrees()));
}
if (sPt.GetLonSigmaDistance().meters() != Null) {
lonSigmaEdit->setText(
QString::number(sPt.GetLonSigmaDistance().meters()));
}
if (sPt.GetLocalRadius().meters() != Null) {
aprioriRadiusEdit->setText(
QString::number(sPt.GetLocalRadius().meters()));
}
if (sPt.GetLocalRadiusSigma().meters() != Null) {
radiusSigmaEdit->setText(
QString::number(sPt.GetLocalRadiusSigma().meters()));
}
}
/**
* Calculates the lat/lon of the ControlNet.
*
* @param incubes The filename of the list of cubes in the ControlNet
* @param cnet The filename of the ControlNet
*/
void setControlPointLatLon(SerialNumberList &snl, ControlNet &cnet) {
CubeManager manager;
manager.SetNumOpenCubes(50); //Should keep memory usage to around 1GB
Progress progress;
progress.SetText("Calculating Lat/Lon");
progress.SetMaximumSteps(cnet.GetNumPoints());
progress.CheckStatus();
for (int cp = 0; cp < cnet.GetNumPoints(); cp++) {
ControlPoint *point = cnet.GetPoint(cp);
ControlMeasure *cm = point->GetRefMeasure();
Cube *cube = manager.OpenCube(snl.FileName(cm->GetCubeSerialNumber()));
try {
cube->camera()->SetImage(cm->GetSample(), cm->GetLine());
g_surfacePoints[point->GetId()] = cube->camera()->GetSurfacePoint();
}
catch (IException &e) {
QString msg = "Unable to create camera for cube file [";
msg += snl.FileName(cm->GetCubeSerialNumber()) + "]";
throw IException(e, IException::Unknown, msg, _FILEINFO_);
}
cube = NULL; //Do not delete, manager still has ownership
progress.CheckStatus();
}
manager.CleanCubes();
}
void RenewSubscriber::run()
{
ControlPoint *ctrlp = getControlPoint();
long renewInterval = RenewSubscriber::INTERVAL * 1000;
while (isRunnable() == true) {
Wait(renewInterval);
ctrlp->renewSubscriberService();
}
}
void Disposer::run()
{
ControlPoint *ctrlp = getControlPoint();
long monitorInterval = ctrlp->getExpiredDeviceMonitoringInterval() * 1000;
while (isRunnable() == true) {
uHTTP::Wait(monitorInterval);
ctrlp->removeExpiredDevices();
//ctrlp->print();
}
}
void SSDPSearchResponseSocket::run()
{
ControlPoint *ctrlPoint = getControlPoint();
while (isRunnable() == true) {
//Thread.yield();
SSDPPacket *packet = receive();
if (packet == NULL)
continue;
if (ctrlPoint != NULL)
ctrlPoint->searchResponseReceived(packet);
}
}
void FFTSplineControl::stretchControlPoints(float factor)
{
for(unsigned int i = 0; i < controlPoints.size(); i++)
{
ControlPoint *cp = controlPoints[i];
assert(cp != NULL);
float x = cp->getPosition().getX();
x *= factor;
cp->getPosition().setX(x);
}
}
void QnetSetAprioriDialog::unlockPoint(QListWidgetItem *pointId) {
ControlPoint *pt = m_qnetTool->controlNet()->GetPoint(pointId->text());
if (pt->IsEditLocked() && pointId->checkState() == Qt::Unchecked) {
pt->SetEditLock(false);
editLockPointsListBox->removeItemWidget(pointId);
pointId->setHidden(true);
editLockPointsListBox->repaint();
this->repaint();
emit netChanged();
}
}
QDebug operator<<(QDebug debug, const ControlPoint &controlPoint)
{
if (controlPoint.isValid()) {
debug.nospace() << "ControlPoint("
<< controlPoint.coordinate().x() << ", "
<< controlPoint.coordinate().y() << ", "
<< controlPoint.pointType() << ')';
} else {
debug.nospace() << "ControlPoint(invalid)";
}
return debug.space();
}
unsigned int Editor::getRelationSecondControlPointIndex(unsigned int relationId)
{
CSP* containingCSP = m_relationIdToContainingCSP[relationId];
AntPostRelation* relation = containingCSP->getAntPostRelationById(relationId);
if (relation == NULL) {
return NO_ID;
}
ControlPoint* currentControlPoint = (ControlPoint*) relation->entity2();
return currentControlPoint->getId();
}
void SplineControl::registerControlPoint(const Point2f &p)
{
ControlPoint *controlPoint = new ControlPoint(p, height * CONTROL_POINT_SIZE);
controlPoint->setFingerDragged(MakeDelegate(this, &SplineControl::controlPoint_FingerDragged));
controlPoint->setFingerUp(MakeDelegate(this, &SplineControl::controlPoint_FingerUp));
registerInterfaceElement(controlPoint);
controlPoints.push_back(controlPoint);
sort(controlPoints.begin(), controlPoints.end(), &ControlPoint::compare);
fullLengthDirty = true;
dirty = true;
splineDirty = true;
}
bool PortMapper::addPortMapping(Device& igd, PortMapping& pm)
{
bool rval = false;
// get wan IP connection service from device
ControlPoint cp;
Service wipcs = cp.getWanIpConnectionService(igd);
if(!wipcs.isNull())
{
// add port mapping
rval = cp.addPortMapping(pm, wipcs);
}
return rval;
}
/*
void SplineControl::renderSplineControl(float SplineControlWidth)
{
glPushAttrib(GL_LINE_BIT | GL_CURRENT_BIT);
glColor4f(1.0f, 1.0f, 1.0, 1.0f);
glLineWidth(getLineWidth(2.0f));
glEnable(GL_LINE_SMOOTH);
glBegin(GL_LINE_STRIP);
float increment = InterfaceManager::getBeatLength() / (float)InterfaceManager::VALUES_PER_BEAT;
for(float f = 0.0; f <= SplineControlWidth; f+= (increment / (float)UPSAMPLE_FACTOR))
{
float legendlessHeight = height - ((height * LEGEND_DIM) * 2.0f);
float value = getValue(f);
float vx = f;
float vy = (value * legendlessHeight) + (height * LEGEND_DIM);
glVertex3f(vx, height - vy, 0.0f);
}
glEnd();
glDisable(GL_LINE_SMOOTH);
glPopAttrib();
}
*/
void SplineControl::savePreset(unsigned int presetType)
{
WavesGlobalState *wavesGlobalState = WavesGlobalState::getInstance();
assert(wavesGlobalState != NULL);
std::map<unsigned int, SplinePreset *> &splinePresets = wavesGlobalState->getSplinePresets();
unsigned int numControlPoints = controlPoints.size();
if(numControlPoints > 0)
{
std::vector<const Point2f> points;
for(unsigned int i = 0; i < numControlPoints; i++)
{
ControlPoint *cp = controlPoints[i];
assert(cp != NULL);
const Point2f &cPos = cp->getPosition();
float sx = cPos.getX() / width;
float sy = cPos.getY() / height;
Point2f sp(sx, sy);
points.push_back(sp);
}
// HACK : assume that if saved and Id in particular range, it must be a default and so save an altered copy
if((!presetSaved && numControlPoints > 0) || (presetSaved && presetId >= 0 && presetId <= 5))
{
unsigned int pId = SplinePreset::generateId();
SplinePreset *preset = new SplinePreset(pId, points, width, (SplinePreset::PresetType)presetType);
assert(preset != NULL);
splinePresets[pId] = preset;
preset->save();
presetId = pId;
presetSaved = true;
}
else
{
SplinePreset *preset = splinePresets[presetId];
assert(preset != NULL);
preset->setPoints(points);
preset->save();
}
}
}
void SplineControl::controlPoint_FingerDragged(ControlPoint &cp, const FingerEventArgs &e)
{
assert(modelview != NULL);
Point2f p = e.getPosition();
modelview->unTranslatePoint(p);
modelview->unScalePoint(p);
cp.setPosition(p);
sort(controlPoints.begin(), controlPoints.end(), &ControlPoint::compare);
cp.setInside(controlPointContains(e));
fullLengthDirty = true;
dirty = true;
splineDirty = true;
}
bool AnimationPath::getInterpolatedControlPoint(double time,ControlPoint& controlPoint) const
{
if (_timeControlPointMap.empty()) return false;
switch(_loopMode)
{
case(SWING):
{
double modulated_time = (time - getFirstTime())/(getPeriod()*2.0);
double fraction_part = modulated_time - floor(modulated_time);
if (fraction_part>0.5) fraction_part = 1.0-fraction_part;
time = getFirstTime()+(fraction_part*2.0) * getPeriod();
break;
}
case(LOOP):
{
double modulated_time = (time - getFirstTime())/getPeriod();
double fraction_part = modulated_time - floor(modulated_time);
time = getFirstTime()+fraction_part * getPeriod();
break;
}
case(NO_LOOPING):
// no need to modulate the time.
break;
}
TimeControlPointMap::const_iterator second = _timeControlPointMap.lower_bound(time);
if (second==_timeControlPointMap.begin())
{
controlPoint = second->second;
}
else if (second!=_timeControlPointMap.end())
{
TimeControlPointMap::const_iterator first = second;
--first;
// we have both a lower bound and the next item.
// delta_time = second.time - first.time
double delta_time = second->first - first->first;
if (delta_time==0.0)
controlPoint = first->second;
else
{
controlPoint.interpolate((time - first->first)/delta_time,
first->second,
second->second);
}
}
else // (second==_timeControlPointMap.end())
{
controlPoint = _timeControlPointMap.rbegin()->second;
}
return true;
}
static SelectionPoint createSelectionPoint(const ControlPoint &controlPoint)
{
SelectionPoint selectionPoint;
selectionPoint.controlPoint = controlPoint;
selectionPoint.startPosition = controlPoint.coordinate();
return selectionPoint;
}
float SplineControl::getValueFromControlPoint(ControlPoint &cp)
{
float legendHeight = height * LEGEND_DIM;
float legendlessHeight = height - (legendHeight * 2.0f);
float cpy = 1.0f - ((cp.getPosition().getY() - legendHeight) / legendlessHeight);
cpy = constrainYVal(cpy);
return cpy;
}
qint32 CTPGeoReference::setControlPoint(const ControlPoint &pnt)
{
qint32 rec = index(Pixel(pnt.gridLocation()));
if ( rec == iUNDEF) {
_controlPoints.push_back(pnt);
return (qint32)_controlPoints.size() - 1;
}
controlPoint(rec) = pnt;
return rec;
}
int main(int argc, char* argv[]) {
qRegisterMetaType<ArgMap>("ArgMap");
qRegisterMetaType<QDomDocument>("QDomDocument");
QApplication app(argc,argv);
app.setOrganizationName("qsonos");
app.setApplicationName("qsonos");
wnd = new PlayerWindow;
wnd->show();
ControlPoint cp;
QObject::connect(&cp, SIGNAL(newDevice(Device*)),
wnd, SLOT(foundDevice(Device*)));
cp.listen();
cp.discover("urn:schemas-upnp-org:device:ZonePlayer:1");
return app.exec();
}
void
CSPold::updateFromSolver()
{
map<unsigned int, ConstrainedTemporalEntity*>::iterator it = _cedEntities->begin();
while (it != _cedEntities->end())
{
ConstrainedBox* constrainedBox = (ConstrainedBox*) it->second;
vector<CSPConstrainedVariable*> *vars = constrainedBox->variables();
for (unsigned int v = 0; v<vars->size(); v++) {
vars->at(v)->setValue(_solver->getVariableValue(vars->at(v)->getID()));
}
vector<unsigned int>* controlPointID = new vector <unsigned int>;
constrainedBox->getAllControlPointsId(controlPointID);
for (unsigned int j = 0 ; j < controlPointID->size() ; ++j)
{
ControlPoint* controlPoint = constrainedBox->getControlPoint(controlPointID->at(j));
vector<CSPConstrainedVariable*> *varsControl = controlPoint->variables();
for (unsigned int v = 0; v<varsControl->size(); v++) {
varsControl->at(v)->setValue(_solver->getVariableValue(varsControl->at(v)->getID()));
}
}
it++;
delete vars;
}
// for (unsigned int i=0; i<_temporalRelations->size(); i++) {
// if (dynamic_cast<IntervalRelation*>(_temporalRelations->at(i))) {
// _solver->getVariableValue( dynamic_cast<IntervalRelation*>(_temporalRelations->at(i))->varID());
// _solver->getVariableValue(_temporalRelations->at(i)->entity2()->beginID());
// _solver->getVariableValue(_temporalRelations->at(i)->entity1()->beginID());
// _solver->getVariableValue(_temporalRelations->at(i)->entity1()->lengthID());
// }
// }
}
int PortMapper::discoverGateways(uint32_t timeout)
{
int rval = -1;
mCacheLock.lockExclusive();
{
// clear cache
mGatewayCache->clear();
// search for 1 internet gateway device
DeviceDiscoverer dd;
rval = dd.discover(mGatewayCache, UPNP_DEVICE_TYPE_IGD, timeout, 1);
if(rval)
{
// default to error case
rval = -1;
// get device description
Device igd = mGatewayCache.first();
ControlPoint cp;
if(cp.getDeviceDescription(igd))
{
// get wan IP connection service from device
Service wipcs = cp.getWanIpConnectionService(igd);
if(!wipcs.isNull())
{
// get service description
if(cp.getServiceDescription(wipcs))
{
// useful device found
rval = 1;
}
}
}
}
}
mCacheLock.unlockExclusive();
return rval;
}
void SplineControl::snapControlPoint(ControlPoint &cp)
{
float cpx = cp.getPosition().getX();
float cpy = cp.getPosition().getY();
// clamp x
if(cpx < 0.0f) cpx = 0.0f;
else if(cpx > width) cpx = width;
// clamp y
float legendDim = (height * LEGEND_DIM);
if(cpy < legendDim) cpy = legendDim;
else if(cpy > height - legendDim) cpy = (height - legendDim);
// snap
float snapIncrement = InterfaceManager::getBeatLength() / (float)BEAT_SNAP;
float divs = floorf((cpx + (snapIncrement * 0.5f)) / snapIncrement);
cpx = snapIncrement * divs;
cp.getPosition().setX(cpx);
cp.getPosition().setY(cpy);
}
void SSDPNotifySocket::run() {
while (isRunnable() == true) {
SSDPPacket ssdpPacket;
if (!receive(&ssdpPacket))
break;
ControlPoint *ctrlPoint = getControlPoint();
if (!ctrlPoint)
break;
if (!ssdpPacket.isNotifyRequest())
continue;
std::string ssdpNTS, ssdpNT, ssdpLocation;
ssdpPacket.getNTS(ssdpNTS);
ssdpPacket.getNT(ssdpNT);
ssdpPacket.getLocation(ssdpLocation);
LogTrace("SSDP Notify Received : %s %s %s", ssdpNTS.c_str(), ssdpNT.c_str(), ssdpLocation.c_str());
ctrlPoint->notifyReceived(&ssdpPacket);
}
}
bool PortMapper::removePortMapping(Device& igd, PortMapping& pm, bool ignoreDne)
{
bool rval = false;
// get wan IP connection service from device
ControlPoint cp;
Service wipcs = cp.getWanIpConnectionService(igd);
if(!wipcs.isNull())
{
// remove port mapping
bool dne = false;
rval = cp.removePortMapping(pm, wipcs, &dne);
// ignore does not exist errors if requested
if(!rval && ignoreDne && dne)
{
Exception::clear();
rval = true;
}
}
return rval;
}
/**
* Set control points in the dialog
*
* @param selectedPoints QList<QListWidgetItem *> ControlPoints listed
*
* @internal
* @history 2011-10-03 Tracie Sucharski - Do not enable user Entered Button,
* this will only be enabled if the group box is enabled.
*/
void QnetSetAprioriDialog::setPoints(QList<QListWidgetItem *> selectedPoints) {
editLockPointsListBox->clear();
clearLineEdits();
m_points = selectedPoints;
if (m_points.size() == 1) {
fillLineEdits();
}
else {
userEnteredRadioButton->setEnabled(false);
}
// Fill editLock List Box
for (int i=0; i<m_points.size(); i++) {
QString id = m_points.at(i)->text();
ControlPoint *pt = m_qnetTool->controlNet()->GetPoint(id);
if (pt->IsEditLocked()) {
QListWidgetItem *item = new QListWidgetItem(*(m_points[i]));
item->setCheckState(Qt::Checked);
editLockPointsListBox->addItem(item);
}
}
}
void Board::animate(int toX, int toY)
{
int positionX, positionY;
std::string player_aux = currentPlayer;
// find player position
for(int i=0; i < 5; i++)
{
for (int j=0; j<5; j++)
{
if(board[i][j][0] == player_aux[0] && board[i][j][1] != '4')
{
positionX = i;
positionY = j;
}
}
}
this->pieceToAnimate[0] = positionX;
this->pieceToAnimate[1] = positionY;
this->hasAnimation = true;
this->animation = new LinearAnimation("animation", 0);
ControlPoint initialPoint = this->getOpenGlPosition(positionX, positionY);
ControlPoint finalPoint = this->getOpenGlPosition(toX, toY);
ControlPoint initialPointHeight = ControlPoint(initialPoint.getX(), initialPoint.getY() + 10, initialPoint.getZ());
ControlPoint finalPointHeight = ControlPoint(finalPoint.getX(), finalPoint.getY() + 10, finalPoint.getZ());
this->animation->addControlPoint(initialPoint);
this->animation->addControlPoint(initialPointHeight);
this->animation->addControlPoint(finalPointHeight);
this->animation->addControlPoint(finalPoint);
this->animation->calculateTotalDistance();
//cout << positionX << " to " << toX << endl;
//cout << positionY << " to " << toY << endl;
}
//--------------------------------------------------------------
void testApp::update(){
float elapsed = (ofGetElapsedTimef() - startTime);
switch (status) {
case VISIBLE:
break;
case FORWARD:
if (elapsed > maxDuration) {
vector<ofVec3f> verts = mesh.getVertices();
for (vector<ofVec3f>::iterator it=verts.begin(); it!=verts.end(); ++it) {
it->x = clickedPosition.x;
it->y = clickedPosition.y;
}
status = INVISIBLE;
break;
}
for (int y=0; y<rows; ++y) {
for (int x=0; x<cols; ++x) {
for (int i=0; i<6; ++i) {
int index = 6*(y*cols+x) + i;
ControlPoint p = controlPoints[index];
float easedValue = easingForward(ofClamp(elapsed / p.getDuration(), 0.0, 1.0));
ofVec3f v;
v.x = p.x + easedValue*(clickedPosition.x - p.x);
v.y = p.y + easedValue*(clickedPosition.y - p.y);
v.z = 0;
mesh.setVertex(index, v);
}
}
}
break;
case INVISIBLE:
break;
case BACKWARD:
if (elapsed > maxDuration) {
vector<ofVec3f> verts = mesh.getVertices();
for(int i=0; i<verts.size(); ++i) {
verts[i].x = controlPoints[i].x;
verts[i].y = controlPoints[i].y;
}
status = VISIBLE;
break;
}
for (int y=0; y<rows; ++y) {
for (int x=0; x<cols; ++x) {
for (int i=0; i<6; ++i) {
int index = 6*(y*cols+x) + i;
ControlPoint p = controlPoints[index];
float easedValue = easingBackward(ofClamp(elapsed / p.getDuration(), 0.0, 1.0));
ofVec3f v;
v.x = clickedPosition.x + easedValue*(p.x - clickedPosition.x);
v.y = clickedPosition.y + easedValue*(p.y - clickedPosition.y);
v.z = 0;
mesh.setVertex(index, v);
}
}
}
break;
}
}
bool OpacityTransferFunctionWidget::AddControlPoint(int px, int py) {
// Box coordinates
float bx = 0.0;
float by = 0.0;
// Control point
ControlPoint controlPoint;
// Function coordinates
float scalar = 0.0;
float opacity = 0.0;
// World coordinates
float wx = 0.0;
float wy = 0.0;
// Check that pixel coordinates are within world space
if (IsPixelInWorld(px, py) == true) {
// Get corresponding world coordinates
PixelToWorld(px, py, &wx, &wy);
// Check that world coordinates are within box space
if (IsWorldInBox(wx, wy) == true) {
// Get corresponding box coordinates
WorldToBox(wx, wy, &bx, &by);
// Get corresponding function coordinates
BoxToFunction(bx, by, &scalar, &opacity);
// Set control point
controlPoint.SetOpacity(opacity);
controlPoint.SetScalar(scalar);
// Add control point
_controlPoint.push_back(controlPoint);
// Sort control points
sort(_controlPoint.begin(), _controlPoint.end());
// Get index of newly added point
_focusPoint = GetControlPointIndex(scalar, opacity);
// Increment number of control points
_numberOfControlPoints++;
// Control point added
return true;
}
}
// Set focus point
_focusPoint = -1;
// Did not add control point
return false;
}
OpacityTransferFunctionWidget::OpacityTransferFunctionWidget(int w, int h) {
// Initialize background color
_backgroundColor[0] = 0.0;
_backgroundColor[1] = 0.0;
_backgroundColor[2] = 0.0;
_backgroundColor[3] = 0.0;
// Initialize box bound
_boxBound[0] = 0.0;
_boxBound[1] = 0.0;
_boxBound[2] = 0.0;
_boxBound[3] = 0.0;
// Initialize box color
_boxColor[0] = 1.0;
_boxColor[1] = 1.0;
_boxColor[2] = 1.0;
_boxColor[3] = 1.0;
// Initialize control point color
_controlPointColor[0] = 1.0;
_controlPointColor[1] = 1.0;
_controlPointColor[2] = 1.0;
_controlPointColor[3] = 1.0;
// Initialize control point size
_controlPointSize = 8;
// Initialize focus point index
_focusPoint = -1;
// Initialize focus point color
_focusPointColor[0] = 0.0;
_focusPointColor[1] = 0.0;
_focusPointColor[2] = 0.0;
_focusPointColor[3] = 1.0;
// Initialize frustum
_frustum[0] = 0.0;
_frustum[1] = 1.0;
_frustum[2] = 0.0;
_frustum[3] = 1.0;
_frustum[4] = -1.0;
_frustum[5] = 1.0;
// Initialize line color
_lineColor[0] = 1.0;
_lineColor[1] = 1.0;
_lineColor[2] = 1.0;
_lineColor[3] = 1.0;
// Initialize number of control points
_numberOfControlPoints = 0;
// Initialize opacity range
_opacityMaximum = 1.0;
_opacityMinimum = 0.0;
// Initialize size of window
_pixelDimensions[0] = w;
_pixelDimensions[1] = h;
// Initialize scalar range
_scalarMaximum = 1.0;
_scalarMinimum = 0.0;
// Initialize text color
_textColor[0] = 1.0;
_textColor[1] = 1.0;
_textColor[2] = 1.0;
_textColor[3] = 1.0;
// Initialize transfer function
ControlPoint controlPoint;
// First control point
controlPoint.SetScalar(0.0);
controlPoint.SetOpacity(0.0);
_controlPoint.push_back(controlPoint);
// Second control point
controlPoint.SetScalar(1.0);
controlPoint.SetOpacity(1.0);
_controlPoint.push_back(controlPoint);
// Increment number of control points
_numberOfControlPoints = 2;
}
