/* * Draw the stool * Stool's base height is 0 (on the floor) * Dimensions: * Seat diameter: 11 3/4 " * Width: 14 5/8 " * Depth: 19 5/8 " * Min. seat height: 24 3/4 " * Max. seat height: 29 1/8 " */ void Stool::draw(MatrixStack &mViewStack) { mViewStack.push(); // position stool with feet on the floor mViewStack.active = glm::translate(mViewStack.active, glm::vec3(0.0f, STOOL_HEIGHT, 0.0f)); // seat and stem rendering mViewStack.push(); // used in height adjustment controls mViewStack.active = glm::translate(mViewStack.active, glm::vec3(0.0f, heightAdjust, 0.0f)); drawSeatAndStem(mViewStack); mViewStack.pop(); // leg rendering drawLeg(mViewStack, 0); drawLeg(mViewStack, 90); drawLeg(mViewStack, 180); drawLeg(mViewStack, 270); // draw lower ring drawRing(mViewStack); // draw upper disks drawDisk(mViewStack, TOP_DISK_RAD, 23.75f); drawDisk(mViewStack, BOT_DISK_RAD, 21.25f); mViewStack.pop(); }
void BitObject::drawOutline(Image<T_or_RGB>& img, const T_or_RGB& color, float opacity) { ASSERT(isValid()); ASSERT(img.initialized()); float op2 = 1.0F - opacity; Dims d = img.getDims(); Image<byte> mask = getObjectMask(); // rescale if needed if (d != itsImageDims) mask = rescaleNI(mask, d.w(), d.h()); // object-shaped drawing int thick = 1; Image<byte> om(mask); om = contour2D(om); // compute binary contour image const int w = img.getWidth(); const int h = img.getHeight(); Point2D<int> ppp; for (ppp.j = 0; ppp.j < h; ppp.j ++) for (ppp.i = 0; ppp.i < w; ppp.i ++) if (om.getVal(ppp.i, ppp.j)) // got a contour point -> draw here drawDisk(img, ppp, thick, T_or_RGB(img.getVal(ppp) * op2 + color * opacity)); // small disk for each point } // end drawOutline
void Simulation::refresh() { SDL_RenderClear(renderer); for (Particle *p : particles) { SDL_SetRenderDrawColor(renderer, p->getR(), p->getG(), p->getB(), 255); drawDisk(p->getX(), p->getY(), p->getRadius()); resetBackgroundColor(); } SDL_RenderPresent(renderer); }
//---------------------------------------------------------------------------------------------------------------------- void CTRNNViz::drawNeuron(int i, const CTRNN* ctrnn, float inner, float outer) { // white background glColor3f(1,1,1); drawDisk(outer, 0.0, 32, 1); // disk size indicating output value ci::Color col = ctrnn->getState(i) > 0 ? ci::Color(0,0,0) : ci::Color(235.0/255.0, 0.0/255.0, 103.0/255.0); if (ctrnn->getOutput(i) < 0) col = ci::Color(235.0/255.0, 0.0/255.0, 103.0/255.0); ci::gl::color(col); drawDisk(inner * clamp(getOutputNorm(i, ctrnn), 0.0, 1.0), 0.0, 32, 1); // ring size indicating external input value //glColor3f(181.0/255.0, 206.0/255.0, 26.0/255.0); col = ctrnn->getExternalInput(i) > 0 ? ci::Color(185/255.0, 185/255.0, 185/255.0) : ci::Color(235.0/255.0, 205.0/255.0, 221.0/255.0); ci::gl::color(col); float width = radiansToDegrees(ctrnn->getExternalInput(i) * TWO_PI); dmx::drawPartialDisk(inner, outer, 32, 1, 0, width, GLU_FILL); glColor3f(0,0,0); ci::gl::drawStrokedCircle(ci::Vec2f(0,0), outer, 32); ci::gl::drawStrokedCircle(ci::Vec2f(0,0), inner, 32); }
void QwtPieCurve::draw(QPainter *painter, const QwtScaleMap &xMap, const QwtScaleMap &yMap, int from, int to) const { int size = dataSize(); if (!painter || size <= 0) return; if (to < 0) to = size - 1; if (size > 1) drawSlices(painter, xMap, yMap, from, to); else drawDisk(painter, xMap, yMap); }
void Extract::paintGL() { glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT ); glLoadIdentity(); // light sources glLightfv(GL_LIGHT0, GL_POSITION, xlight0_pos); //glLightfv(GL_LIGHT1, GL_POSITION, light1_pos); Point3D b1, b2; // contents, if necessary const GLfloat xglwater[] = { beakerRed, beakerGreen, beakerBlue, beakerAlpha }; const GLfloat xgloil[] = { oilRed, oilGreen, oilBlue, oilAlpha }; const GLfloat vglcyl[] = { 0.0, 0.0, 1.0, 0.4 }; // no animation if (running == false) { glMaterialfv(GL_FRONT, GL_AMBIENT_AND_DIFFUSE, xglwater); glMaterialfv(GL_FRONT, GL_SPECULAR, xglwater); glMaterialfv(GL_FRONT, GL_SHININESS, xgldull); b1.setXYZ(0.0,-1.25,-10.0); b2.setXYZ(0.0,-4.75,-10.0); drawCylinder(b1,b2,1.9); drawDisk(b2,1.95); glMaterialfv(GL_FRONT, GL_AMBIENT_AND_DIFFUSE, xgloil); glMaterialfv(GL_FRONT, GL_SPECULAR, xgloil); glMaterialfv(GL_FRONT, GL_SHININESS, xgldull); b1.setXYZ(0.0,-1.25 + beakerHeight,-10.0); b2.setXYZ(0.0,-1.25,-10.0); drawCylinder(b1,b2,1.9); drawDisk(b2,1.95); } // flask glMaterialfv(GL_FRONT, GL_AMBIENT_AND_DIFFUSE, xglass); glMaterialfv(GL_FRONT, GL_SPECULAR, xglwhite); glMaterialfv(GL_FRONT, GL_SHININESS, xglpolished); b1.setXYZ(0.0,2.5,-10.0); b2.setXYZ(0.0,-5.0,-10.0); drawCylinder(b1,b2,2.0); // pedestal glMaterialfv(GL_FRONT, GL_AMBIENT_AND_DIFFUSE, xglblack); glMaterialfv(GL_FRONT, GL_SPECULAR, xglwhite); glMaterialfv(GL_FRONT, GL_SHININESS, xglpolished); b1.setXYZ(0.0,-5.0,-10.0); b2.setXYZ(0.0,-6.0,-10.0); drawCylinder(b1,b2,-3.0); // pedestal indicator if (!running) { glMaterialfv(GL_FRONT, GL_AMBIENT_AND_DIFFUSE, xglwhite); } else { glMaterialfv(GL_FRONT, GL_AMBIENT_AND_DIFFUSE, xglblue); } glMaterialfv(GL_FRONT, GL_SPECULAR, xglwhite); glMaterialfv(GL_FRONT, GL_SHININESS, xglpolished); b1.setXYZ(0.0,-5.5,-7.0); drawSphere(b1,0.25); // floor glMaterialfv(GL_FRONT, GL_AMBIENT_AND_DIFFUSE, xglfloor); glMaterialfv(GL_FRONT, GL_SPECULAR, xglwhite); glMaterialfv(GL_FRONT, GL_SHININESS, xglpolished); b1.setXYZ(0.0,-6.0,-10.0); drawDisk(b1,100.0); }
// ###################################################################### Image<byte> getFoeDots (uint step, bool haveMotion, bool haveTempSGrad, bool haveSpatSGrad, float dx, float dy, float dotOrgDSize) { //if(step > NFRAME) return Image<byte>(); Image<byte> temp(WIDTH, HEIGHT, ZEROS); float orgDotSize = 1.0; // create random dot initially if(step == 0) { dots.resize(DOT_NUM); dotSizes.resize(DOT_NUM); for(uint i = 0; i < DOT_NUM; i++) { dots[i] = Point2D<float> (WIDTH * double(rand())/(RAND_MAX + 1.0), HEIGHT * double(rand())/(RAND_MAX + 1.0)); // just do it in order to get identical average size //float range = MAX_DOT_SIZE - MIN_DOT_SIZE; //dotSizes[i] = i*range/(DOT_NUM-1.0)+ double(MIN_DOT_SIZE); dotSizes[i] = orgDotSize; } } // check for out-of-bounds dot needed to be shown for(uint i = 0; i < DOT_NUM; i++) { // NOTE: can also kill dots randomly before going out of the image // NOTE: how about adding new dots in the FOE quadrants if(!temp.getBounds().contains(Point2D<int>(dots[i].i, dots[i].j))) { dots[i] = Point2D<float> (WIDTH * double(rand())/(RAND_MAX + 1.0), HEIGHT * double(rand())/(RAND_MAX + 1.0) ); // keep the sizes or 1.0? dotSizes[i] = orgDotSize; } } // modify sizes according to rules for(uint i = 0; i < DOT_NUM; i++) { if(haveTempSGrad && haveSpatSGrad) { float dist = sqrt(pow((dots[i].i - FOE_X), 2.0) + pow((dots[i].j - FOE_Y), 2.0) ); if(haveMotion) { dotSizes[i] = dotOrgDSize * dist; } // growing, FOE coherent, but not moving else { if(step == 0) { dotSizes[i] = dotOrgDSize * dist; } else { // increase until ABS_MAX_DSIZE, then stop if(dotSizes[i] < ABS_MAX_DSIZE) { dotSizes[i] = (1.0 + DOT_DSIZE) * dotOrgDSize * dist; } // else dot size stays the same } } } else if(haveTempSGrad && !haveSpatSGrad) { // all dot have same size just increase float ds = MAX_DOT_SIZE - MIN_DOT_SIZE; dotSizes[i] = step*ds/(NFRAME - 1.0)+ double(MIN_DOT_SIZE); } else if(!haveTempSGrad && haveSpatSGrad) { float dist = sqrt(pow((dots[i].i - FOE_X), 2.0) + pow((dots[i].j - FOE_Y), 2.0) ); dotSizes[i] = dotOrgDSize * dist; } // else just keep size } // move the dots if needed if(haveMotion) for(uint i = 0; i < DOT_NUM; i++) { dots[i] = Point2D<float> (dots[i].i + DOT_VEL * (dots[i].i - FOE_X), dots[i].j + DOT_VEL * (dots[i].j - FOE_Y)); } // add lateral motion if(dx != 0.0 || dy != 0.0) for(uint i = 0; i < DOT_NUM; i++) { dots[i] = Point2D<float>(dots[i].i + dx, dots[i].j + dy); } // finally draw the dots for(uint i = 0; i < DOT_NUM; i++) { //LINFO("loc: %10.3f %10.3f: size: %7.3f", // dots[i].i, dots[i].j, dotSizes[i]); drawDisk(temp,Point2D<int>(dots[i].i, dots[i].j),dotSizes[i],byte(255)); //temp.setVal(dots[i].i, dots[i].j, byte(128)); } // draw the FOE //drawDisk(temp,Point2D<int>(FOE_X,FOE_Y),2,byte(128)); return temp; }
// ###################################################################### Image<byte> getPlanarMotionStimuli (Image<byte> temp, uint step, float dx, float dy) { //if(step > NFRAME) return Image<byte>(); uint dotNum = 200;//200;//DOT_NUM; float orgDotSize = 1.0; // create random dot initially if(step == 0) { pdots.resize(dotNum); pdotSizes.resize(dotNum); for(uint i = 0; i < dotNum; i++) { pdots[i] = Point2D<float> (WIDTH * double(rand())/(RAND_MAX + 1.0), HEIGHT * double(rand())/(RAND_MAX + 1.0)); pdotSizes[i] = orgDotSize; } } // check for out-of-bounds dot needed to be shown for(uint i = 0; i < dotNum; i++) { // NOTE: can also kill dots randomly before going out of the image if(!temp.getBounds().contains(Point2D<int>(pdots[i].i, pdots[i].j))) { float srx = 0.0; float sry = 0.0; float rx = WIDTH; float ry = HEIGHT; if(dx < 0.0) { srx = 7.0*WIDTH/8.0; rx = WIDTH/8; } else if(dx > 0.0){ srx = 0.0; rx = WIDTH/8; } if(dy < 0.0) { sry = 7.0*HEIGHT/8.0; ry = HEIGHT/8; } else if(dy > 0.0){ sry = 0.0; ry = HEIGHT/8; } float sx = rx * double(rand())/(RAND_MAX + 1.0) + srx; float sy = ry * double(rand())/(RAND_MAX + 1.0) + sry; pdots[i] = Point2D<float>(sx,sy); pdotSizes[i] = orgDotSize; LDEBUG("new dots[%3d]: %7.3f %7.3f", i, sx, sy); } else { Point2D<int> pt(pdots[i].i, pdots[i].j); LDEBUG("[%3d] it's ok: (%7.3f %7.3f) -> %3d %3d", i, pdots[i].i, pdots[i].j, pt.i, pt.j); } } // planar motion if(dx != 0.0 || dy != 0.0) for(uint i = 0; i < dotNum; i++) { pdots[i] = Point2D<float>(pdots[i].i + dx, pdots[i].j + dy); } // finally draw the dots for(uint i = 0; i < dotNum; i++) { LDEBUG("[%d] loc: %10.3f %10.3f: size: %7.3f", i, pdots[i].i, pdots[i].j, pdotSizes[i]); drawDisk(temp,Point2D<int>(pdots[i].i, pdots[i].j), pdotSizes[i],byte(255)); //temp.setVal(pdots[i].i, pdots[i].j, byte(128)); } return temp; }
//---------------------------------------------------------------------------------------------------------------------- void SMCEnvironmentViz::update() { glPushAttrib(GL_LIGHTING); glDisable(GL_LIGHTING); for(int i = 0; i < m_environment->getObjects().size(); i++) { const Positionable& obj = *m_environment->getObjects()[i]; if(obj.isVisible()) { ci::gl::color(obj.getColor()); // Object specific collision detection if(obj.getType() == Positionable::kObj_Line) { const Line& line = (Line&)obj; ci::gl::drawLine(line.getStart(), line.getEnd()); } else if (obj.getType() == Positionable::kObj_Triangle) { const Triangle& tri = (Triangle&)obj; drawTriangle(ci::Vec3f(tri.p1), ci::Vec3f(tri.p2), ci::Vec3f(tri.p3)); } else if (obj.getType() == Positionable::kObj_Circle) { const Circle& circle = (Circle&)obj; ci::gl::drawSolidCircle(circle.getPosition(), circle.getRadius(), 32); } else if (obj.getType() == Positionable::kObj_Torus) { // Width specifies inflection points. For drawing we use the "half width at tenth of maximum" const Torus& t = (Torus&)obj; const ci::Vec2f& p = t.getPosition(); glPushMatrix(); glTranslatef(p.x, p.y, 0); //ci::gl::drawStrokedCircle(t.getPosition(), t.getRadius() - 2.15 * t.getWidth(), 32); //ci::gl::drawStrokedCircle(t.getPosition(), t.getRadius() + 2.15 * t.getWidth(), 32); //glColor3f(1,0,0); drawDisk(t.getRadius() + 2.15 * t.getWidth(), t.getRadius() - 2.15 * t.getWidth(), 32, 2, GLU_FILL); glPopMatrix(); } else if (obj.getType() == Positionable::kObj_Gradient) { const Gradient& g = (Gradient&)obj; const ci::Vec2f& p = g.getPosition(); ci::ColorA c = ci::ColorA(1,1,1,1); glPushMatrix(); glTranslatef(p.x, p.y, 0); drawRadialGradient(obj.getColor(), c, 32, g.getRadius()); //glColor3f(0.9,0.9,0.9); //drawDisk(g.getRadius(), 0, 32, 2, GLU_SILHOUETTE); glPopMatrix(); } else if (obj.getType() == Positionable::kObj_Gaussian) { const Gaussian& gaus = (Gaussian&)obj; drawGaussian(gaus); } #if DMX_ENV_DRAW_POS dmx::drawPoint(ci::Vec3f(obj.getPosition()), 4); #endif } } glPopAttrib(); }
//---------------------------------------------------------------------------------------------------------------------- void SMCAgentViz::update() { glDisable(GL_DEPTH_TEST); // data const ci::Vec2f& pos = m_agent->getPosition(); float angle = m_agent->getAngle(); // Update trajectory if(!m_paused && m_steps % 2 == 0){ m_traj.push_back(pos); if(m_traj.size() >= 800) { m_traj.pop_front(); } } m_steps++; // pose m_pTM->setToIdentity(); m_pTM->setTranslate(ci::Vec3f(pos)); m_pTM->rotate(ci::Vec3f(0.0f, 0.0f, 1.0f), angle); NodeGroup::update(); // draw glPushAttrib(GL_LIGHTING); glDisable(GL_LIGHTING); // Trajectory ci::ColorA trajCol (235.0/255.0, 89.0/255.0, 55.0/255.0, 1.0); glEnableClientState(GL_VERTEX_ARRAY); glEnableClientState(GL_COLOR_ARRAY); int numPoints = m_traj.size(); float lineVerts[numPoints*2]; float colors[numPoints*4]; glVertexPointer(2, GL_FLOAT, 0, lineVerts); // 2d positions glColorPointer(4, GL_FLOAT, 0, colors); // 4d colors for(size_t i = 0; i < numPoints; i++) { lineVerts[i*2 + 0] = m_traj[i].x; lineVerts[i*2 + 1] = m_traj[i].y; float a = (float)i / (float)numPoints; colors[i*4 + 0] = trajCol[0]; colors[i*4 + 1] = trajCol[1]; colors[i*4 + 2] = trajCol[2]; colors[i*4 + 3] = a; } glLineWidth(2.0); glDrawArrays( GL_LINE_STRIP, 0, numPoints); glDisableClientState(GL_VERTEX_ARRAY); glDisableClientState(GL_COLOR_ARRAY); glLineWidth(1.0); // This is in world space glColor3f(0, 0, 0); const float velScale = 0.1f; glLineWidth(2.0); ci::gl::drawLine(m_agent->getPosition(), m_agent->getPosition() + m_agent->getVelocity() * velScale); glLineWidth(1.0); if(m_agent->hasDistanceSensor()) { DistanceSensor* sensor = m_agent->getDistanceSensor(); float sensedDistance = sensor->getDistance(); glEnable(GL_LINE_STIPPLE); glLineStipple(2, 0xAAAA); glColor3f(0.2, 0.2, 0.2); ci::gl::drawLine(sensor->getPosition(), sensor->getPosition() + sensor->getDirection() * sensedDistance); glDisable(GL_LINE_STIPPLE); glColor3f(1,0,0); if(sensedDistance < sensor->getMaxDistance()) { drawPoint(ci::Vec3f(sensor->getCollision()), 5.0f); } // Sensor in local space glPushMatrix(); glMultMatrixf(*m_pTM); glTranslatef(m_agent->getRadius(), 0, 0.001); float act = m_agent->getDistanceSensor()->getDistanceProportional(); glColor3f(act,act,act); drawDisk(m_agent->getRadius() / 4.0, 0, 16, 2, GLU_FILL); glColor3f(0,0,0); drawDisk(m_agent->getRadius() / 4.0, 0, 16, 2, GLU_SILHOUETTE); glPopMatrix(); } if(m_agent->hasGradientSensor()) { GradientSensor* sensor = m_agent->getGradientSensor(); float s = 1.0f - sensor->getActivation(); // Sensor in local space glPushMatrix(); glTranslatef(sensor->getPosition().x, sensor->getPosition().y, 0.0); glColor3f(s,s,s); drawDisk(m_agent->getRadius() / 4.0, 0, 16, 2, GLU_FILL); glColor3f(0,0,0); drawDisk(m_agent->getRadius() / 4.0, 0, 16, 2, GLU_SILHOUETTE); glPopMatrix(); } if(m_agent->hasTorusSensor()) { Sensor* sensor = m_agent->getTorusSensor(); float s = 1.0f - sensor->getActivation(); // Sensor in local space glPushMatrix(); glTranslatef(sensor->getPosition().x, sensor->getPosition().y, 0.0); glColor3f(s,s,s); drawDisk(m_agent->getRadius() / 4.0, 0, 16, 2, GLU_FILL); glColor3f(0,0,0); drawDisk(m_agent->getRadius() / 4.0, 0, 16, 2, GLU_SILHOUETTE); glPopMatrix(); } // draw positional range if(m_agent->positionWraps()) { float p = m_agent->getMaxPosition(); ci::gl::drawStrokedRect(ci::Rectf(ci::Vec2f(-p,-p), ci::Vec2f(p,p))); } // Change body color depending on energy level ci::Vec3f col = getColorMapRainbow(m_agent->getEnergy() / 5); ci::Vec4f col4 = ci::Vec4f(col); col4[3] = 0.5; m_agentDisk->m_color = col4; glPopAttrib(); glEnable(GL_DEPTH_TEST); }
//---------------------------------------------------------------------------------------------------------------------- // CTRNNNeuronViz implementation //---------------------------------------------------------------------------------------------------------------------- void CTRNNNeuronViz::update() { glPushAttrib(GL_DEPTH_BUFFER_BIT | GL_LIGHTING_BIT | GL_COLOR_BUFFER_BIT | GL_POLYGON_BIT); glDisable(GL_DEPTH_TEST); glDisable(GL_LIGHTING); glEnable(GL_BLEND); glDisable(GL_CULL_FACE); int N = m_ctrnn->getSize(); // left upper corner of circle's bounding box at 0,0: const float segmentSize = TWO_PI / N; const float networkRadius = m_width / 2.5; const float neuronRadius = networkRadius / N; glPushMatrix(); glMultMatrixf(*m_pTM); // connectivity if(m_renderConnections) { for(int i = 0; i < N; i++) { float angle = -((float)i + 0.5f) * segmentSize + PI_OVER_TWO; Vec3f midPoint (networkRadius * cosf(angle), networkRadius * sinf(angle), 0.0f); // draw only the selected neuron's connections if(i == m_selected || m_selected == -1) { // draw connections for(int j = 0; j < N; j++) { const double eps = 0.001; const float weight = m_ctrnn->getWeight(j,i); if(fabs(weight) > eps) { float otherAngle = -((float)j + 0.5f) * segmentSize + PI_OVER_TWO; Vec3f otherMidPoint (networkRadius * cosf(otherAngle), networkRadius * sinf(otherAngle), 0.0f); glLineWidth(fabs(weight)); if(weight < 0) glColor3f(235.0/255.0, 0.0/255.0, 103.0/255.0); else glColor3f(0,0,0); ci::gl::drawLine(midPoint, otherMidPoint); } } // render text if(m_renderText && i == m_selected) { // box glColor4f(0,0,0, 0.5f); const float lineHeight = 13; const float padding = 3; const float textBoxH = 3 * lineHeight + 2 * padding; ci::Vec2f textBoxPos = ci::Vec2f(&midPoint.x); ci::gl::drawSolidRect(ci::Rectf(textBoxPos.x, textBoxPos.y, textBoxPos.x + m_width, textBoxPos.y + textBoxH)); // text ci::Color textColor(1,1,1); ci::Vec2f textPos = textBoxPos + ci::Vec2f(padding, padding); char str [128]; sprintf(str, "Node: %i", i); ci::gl::drawString(str, textPos, textColor, m_font); sprintf(str, "b: %2.2f | t: %2.2f | g: %2.2f", m_ctrnn->getBias(i), m_ctrnn->getTimeConstant(i), m_ctrnn->getGain(i)); ci::gl::drawString(str, textPos + ci::Vec2f(0, lineHeight), textColor, m_font); sprintf(str, "in: %1.3f | out: %1.3f", m_ctrnn->getExternalInput(i), m_ctrnn->getOutput(i)); ci::gl::drawString(str, textPos + ci::Vec2f(0, 2 * lineHeight), textColor, m_font); } } } } glLineWidth(1.0f); float outerRadius = neuronRadius + (neuronRadius * 0.5); for(int i = 0; i < N; i++) { ci::Color col = m_ctrnn->getState(i) > 0 ? ci::Color(0,0,0) : ci::Color(235.0/255.0, 0.0/255.0, 103.0/255.0); float angle = -((float)i + 0.5f) * segmentSize + PI_OVER_TWO; Vec3f midPoint (networkRadius * cosf(angle), networkRadius * sinf(angle), 0.0f); glPushMatrix(); glTranslatef(midPoint); // white background glColor3f(1,1,1); drawDisk(outerRadius, 0.0, 32, 1); ci::gl::color(col); // disk size indicating output value drawDisk(neuronRadius * clamp(m_ctrnn->getOutput(i),0.0,1.0), 0.0, 32, 1); // ring size indicating external input value glColor3f(181.0/255.0, 206.0/255.0, 26.0/255.0); float width = radiansToDegrees(m_ctrnn->getExternalInput(i) * TWO_PI); dmx::drawPartialDisk(neuronRadius, outerRadius, 32, 1, 0, width, GLU_FILL); glColor3f(0,0,0); ci::gl::drawStrokedCircle(ci::Vec2f(0,0), outerRadius, 32); ci::gl::drawStrokedCircle(ci::Vec2f(0,0), neuronRadius, 32); glPopMatrix(); } glPopMatrix(); glPopAttrib(); }