void CVisSystemCanvasNote::mouseMoveEvent(QGraphicsSceneMouseEvent* me)
{
if(d->resizing)
{
QPointF dp = me->scenePos() - d->mousePos;
prepareGeometryChange();
QRectF r = noteRect();
r.setBottomRight( r.bottomRight()+dp );
if(d->minimumSize.width() > r.width() || d->minimumSize.height() > r.height())
return;
setNoteRect(r);
d->mousePos = me->scenePos();
}
else
QGraphicsRectItem::mouseMoveEvent(me);
}
void DrawWidget::drawChannelFilled(Channel *ch, QPainter &p, double leftTime, double currentTime, double zoomX, double viewBottom, double zoomY, int viewType)
{
ZoomLookup *z;
if(viewType == DRAW_VIEW_SUMMARY) z = &ch->summaryZoomLookup;
else z = &ch->normalZoomLookup;
ChannelLocker channelLocker(ch);
QColor current = ch->color;
QColor invert(255 - current.red(), 255 - current.green(), 255 - current.blue());
p.setPen(current);
int viewBottomOffset = toInt(viewBottom / zoomY);
viewBottom = double(viewBottomOffset) * zoomY;
// baseX is the no. of chunks a pixel must represent.
double baseX = zoomX / ch->timePerChunk();
z->setZoomLevel(baseX);
double currentChunk = ch->chunkFractionAtTime(currentTime);
double leftFrameTime = currentChunk - ((currentTime - leftTime) / ch->timePerChunk());
//double leftFrameTime = leftTime / ch->timePerChunk();
double frameTime = leftFrameTime;
//if(frameTime < 0.0) frameTime = 0.0;
int n = 0;
int baseElement = int(floor(frameTime / baseX));
if(baseElement < 0) { n -= baseElement; baseElement = 0; }
int lastBaseElement = int(floor(double(ch->totalChunks()) / baseX));
int firstN = n;
int lastN = firstN;
//QPointArray pointArray(width()*2);
//QPointArray topPoints(width()*2);
/* Q3PointArray bottomPoints(width()*2);
Q3PointArray evenMidPoints(width()*2);
Q3PointArray oddMidPoints(width()*2);
Q3PointArray evenMidPoints2(width()*2);
Q3PointArray oddMidPoints2(width()*2);*/
QPolygon bottomPoints(width()*2);
QPolygon evenMidPoints(width()*2);
QPolygon oddMidPoints(width()*2);
QPolygon evenMidPoints2(width()*2);
QPolygon oddMidPoints2(width()*2);
std::vector<QRect> noteRect(width()*2);
std::vector<QRect> noteRect2(width()*2);
std::vector<bool> isNoteRectEven(width()*2);
//int pointIndex = 0;
int pointIndex = 0;
int evenMidPointIndex = 0;
int oddMidPointIndex = 0;
int evenMidPointIndex2 = 0;
int oddMidPointIndex2 = 0;
int rectIndex = 0;
int rectIndex2 = 0;
if (baseX > 1) { // More samples than pixels
int theWidth = width();
//if(baseElement + theWidth > z->size()) z->setSize(baseElement + theWidth);
if(lastBaseElement > z->size()) z->setSize(lastBaseElement);
for(; n < theWidth && baseElement < lastBaseElement; n++, baseElement++) {
myassert(baseElement >= 0);
ZoomElement &ze = z->at(baseElement);
//if(!z->hasValue(baseElement)) {
if(!ze.isValid()) {
if(!calcZoomElement(ch, ze, baseElement, baseX)) continue;
}
/*p.setPen(gdata->shading1Color());
p.moveTo(n, 0);
p.lineTo(n, height() - 1 - toInt(ze.high / zoomY) + viewBottomOffset);
p.setPen(gdata->shading2Color());
p.lineTo(n, height());*/
int y = height() - 1 - toInt(ze.high() / zoomY) + viewBottomOffset;
int y2, y3;
//if(ze.noteIndex >= 0) {
if(ze.noteIndex() != -1 && ch->dataAtChunk(ze.midChunk())->getNoteIndex() != -1) {
myassert(ze.noteIndex() >= 0);
myassert(ze.noteIndex() < int(ch->noteData.size()));
myassert(ch->isValidChunk(ze.midChunk()));
AnalysisData *data = ch->dataAtChunk(ze.midChunk());
//double avgNote = ch->noteData[ze.noteIndex()].avgNote();
//printf("avgFreq = %f, ", ch->noteData[ze.noteIndex].avgFreq());
//printf("numPeriods = %f, ", ch->noteData[ze.noteIndex].numPeriods());
//printf("noteLength = %f\n", ch->noteData[ze.noteIndex].noteLength());
//y2 = height() - 1 - toInt((avgNote+0.5) / zoomY) + viewBottomOffset;
//y3 = height() - 1 - toInt((avgNote-0.5) / zoomY) + viewBottomOffset;
//y2 = height() - 1 - toInt((data->shortTermMean + data->shortTermDeviation) / zoomY) + viewBottomOffset;
//y3 = height() - 1 - toInt((data->shortTermMean - data->shortTermDeviation) / zoomY) + viewBottomOffset;
if(gdata->showMeanVarianceBars()) {
//longTermMean bars
y2 = height() - 1 - toInt((data->getLongTermMean() + data->getLongTermDeviation()) / zoomY) + viewBottomOffset;
y3 = height() - 1 - toInt((data->getLongTermMean() - data->getLongTermDeviation()) / zoomY) + viewBottomOffset;
if(ze.noteIndex() % 2 == 0) {
evenMidPoints.setPoint(evenMidPointIndex++, n, y2);
evenMidPoints.setPoint(evenMidPointIndex++, n, y3);
} else {
oddMidPoints.setPoint(oddMidPointIndex++, n, y2);
oddMidPoints.setPoint(oddMidPointIndex++, n, y3);
}
//shortTermMean bars
y2 = height() - 1 - toInt((data->getShortTermMean() + data->getShortTermDeviation()) / zoomY) + viewBottomOffset;
y3 = height() - 1 - toInt((data->getShortTermMean() - data->getShortTermDeviation()) / zoomY) + viewBottomOffset;
if(ze.noteIndex() % 2 == 0) {
evenMidPoints2.setPoint(evenMidPointIndex2++, n, y2);
evenMidPoints2.setPoint(evenMidPointIndex2++, n, y3);
} else {
oddMidPoints2.setPoint(oddMidPointIndex2++, n, y2);
oddMidPoints2.setPoint(oddMidPointIndex2++, n, y3);
}
}
//} else {
// y2 = y3 = 0;
}
//topPoints.setPoint(pointIndex, n, 0);
//topPoints.setPoint(pointIndex, n, y);
bottomPoints.setPoint(pointIndex++, n, y);
bottomPoints.setPoint(pointIndex++, n, height());
lastN = n;
}
//p.setPen(gdata->shading1Color());
//p.drawLineSegments(topPoints, 0, pointIndex/2);
p.setPen(Qt::NoPen);
p.setBrush(gdata->shading1Color());
p.drawRect(firstN, 0, lastN, height());
p.setPen(gdata->shading2Color());
//p.drawLineSegments(bottomPoints, 0, pointIndex/2);
if(pointIndex > 1) p.drawLines(bottomPoints.constData(), pointIndex/2);
if(gdata->showMeanVarianceBars()) {
//shortTermMean bars
p.setPen(Qt::green);
//p.drawLineSegments(evenMidPoints2, 0, evenMidPointIndex2/2);
if(evenMidPointIndex2 > 1) p.drawLines(evenMidPoints2.constData(), evenMidPointIndex2/2);
p.setPen(Qt::yellow);
//p.drawLineSegments(oddMidPoints2, 0, oddMidPointIndex2/2);
if(oddMidPointIndex2 > 1) p.drawLines(oddMidPoints2.constData(), oddMidPointIndex2/2);
//longTermMean bars
p.setPen(Qt::yellow);
//p.drawLineSegments(evenMidPoints, 0, evenMidPointIndex/2);
if(evenMidPointIndex > 1) p.drawLines(evenMidPoints.constData(), evenMidPointIndex/2);
p.setPen(Qt::green);
//p.drawLineSegments(oddMidPoints, 0, oddMidPointIndex/2);
if(oddMidPointIndex > 1) p.drawLines(oddMidPoints.constData(), oddMidPointIndex/2);
}
} else { // More pixels than samples
float err = 0.0;
float pitch = 0.0;
int intChunk = (int) floor(frameTime); // Integer version of frame time
if(intChunk < 0) intChunk = 0;
double stepSize = 1.0 / baseX; // So we skip some pixels
int x = 0, y, y2, y3;
//double start = 0 - stepSize;
double start = (double(intChunk) - frameTime) * stepSize;
double stop = width() + (2 * stepSize);
//int squareSize = (int(sqrt(stepSize)) / 2) * 2 + 1; //make it an odd number
//int halfSquareSize = squareSize/2;
//QPointArray topPoints(0);
//QPointArray bottomPoints(0);
//int pointIndex = 0;
//topPoints.putPoints(pointIndex, 1, toInt(start), 0);
//bottomPoints.putPoints(pointIndex, 1, toInt(start), height());
//pointIndex++;
//topPoints.setPoint(pointIndex, toInt(start), 0);
bottomPoints.setPoint(pointIndex++, toInt(start), height());
lastN = firstN = toInt(start);
for (double n = start; n < stop && intChunk < (int)ch->totalChunks(); n += stepSize, intChunk++) {
myassert(intChunk >= 0);
//if (intChunk < 0) continue; // So we don't go off the beginning of the array
AnalysisData *data = ch->dataAtChunk(intChunk);
err = data->getCorrelation();
//if (err >= CERTAIN_THRESHOLD) {
//float val = MIN(ch->dataAtChunk(intChunk)->volumeValue, 1.0);
if(gdata->pitchContourMode() == 0)
//p.setPen(QPen(colorBetween(colorGroup().background(), ch->color, err*2.0-1.0), lineWidth));
//p.setPen(QPen(colorBetween(gdata->backgroundColor(), ch->color, err*sqrt(data->rms)*10.0), lineWidth));
p.setPen(QPen(colorBetween(QColor(255, 255, 255), ch->color, err * dB2ViewVal(data->getLogRms())), lineWidth));
else
p.setPen(QPen(ch->color, lineWidth));
x = toInt(n);
lastN = x;
//note = (data->isValid()) ? data->note : 0.0f;
//note = (ch->isVisibleNote(data->noteIndex)) ? data->note : 0.0f;
pitch = (ch->isVisibleChunk(data)) ? data->getPitch() : 0.0f;
//if(ch->isVisibleChunk(data)) {
if(data->getNoteIndex() >= 0) {
isNoteRectEven[rectIndex] = (data->getNoteIndex() % 2) == 0;
//note = data->note;
//double avgNote = ch->noteData[data->noteIndex].avgNote();
//y2 = height() - 1 - toInt((avgNote+0.5) / zoomY) + viewBottomOffset;
//y3 = height() - 1 - toInt((avgNote-0.5) / zoomY) + viewBottomOffset;
//y2 = height() - 1 - toInt((data->shortTermMean + data->shortTermDeviation) / zoomY) + viewBottomOffset;
//y3 = height() - 1 - toInt((data->shortTermMean - data->shortTermDeviation) / zoomY) + viewBottomOffset;
if(gdata->showMeanVarianceBars()) {
//longTermMean bars
y2 = height() - 1 - toInt((data->getLongTermMean() + data->getLongTermDeviation()) / zoomY) + viewBottomOffset;
y3 = height() - 1 - toInt((data->getLongTermMean() - data->getLongTermDeviation()) / zoomY) + viewBottomOffset;
noteRect[rectIndex].setLeft(x);
noteRect[rectIndex].setRight(toInt(n+stepSize));
noteRect[rectIndex].setTop(y2);
noteRect[rectIndex++].setBottom(y3);
//shortTermMean bars
y2 = height() - 1 - toInt((data->getShortTermMean() + data->getShortTermDeviation()) / zoomY) + viewBottomOffset;
y3 = height() - 1 - toInt((data->getShortTermMean() - data->getShortTermDeviation()) / zoomY) + viewBottomOffset;
noteRect2[rectIndex2].setLeft(x);
noteRect2[rectIndex2].setRight(toInt(n+stepSize));
noteRect2[rectIndex2].setTop(y2);
noteRect2[rectIndex2++].setBottom(y3);
}
//} else {
// note = 0.0f;
}
myassert(pitch >= 0.0 && pitch <= gdata->topPitch());
//note = bound(note, 0, gdata->topNote());
y = height() - 1 - toInt(pitch / zoomY) + viewBottomOffset;
//y = height() - 1 - int((note / zoomY) - (viewBottom / zoomY));
//topPoints.putPoints(pointIndex, 1, x, y);
//bottomPoints.putPoints(pointIndex, 1, x, y);
//pointIndex++;
//topPoints.setPoint(pointIndex, x, y);
bottomPoints.setPoint(pointIndex++, x, y);
}
//topPoints.putPoints(pointIndex, 1, topPoints.point(pointIndex-1).x(), 0);
//bottomPoints.putPoints(pointIndex, 1, bottomPoints.point(pointIndex-1).x(), height());
//pointIndex++;
//topPoints.setPoint(pointIndex, topPoints.point(pointIndex-1).x(), 0);
bottomPoints.setPoint(pointIndex, bottomPoints.point(pointIndex-1).x(), height());
pointIndex++;
//p.setPen(gdata->shading1Color());
//p.setBrush(gdata->shading1Color());
//p.drawPolygon(topPoints);
//p.setPen(gdata->shading2Color());
//p.setBrush(gdata->shading2Color());
//p.drawPolygon(bottomPoints);
myassert(pointIndex <= width()*2);
//p.setPen(gdata->shading1Color());
p.setPen(Qt::NoPen);
p.setBrush(gdata->shading1Color());
//p.drawPolygon(topPoints, false, 0, pointIndex);
p.drawRect(firstN, 0, lastN, height());
//p.setPen(gdata->shading2Color());
p.setBrush(gdata->shading2Color());
//p.drawPolygon(bottomPoints, false, 0, pointIndex);
p.drawPolygon(bottomPoints.constData(), pointIndex, Qt::OddEvenFill);
if(gdata->showMeanVarianceBars()) {
//shortTermMean bars
for(int j=0; j<rectIndex2; j++) {
if(isNoteRectEven[j]) p.setBrush(Qt::green);
else p.setBrush(Qt::yellow);
p.drawRect(noteRect2[j]);
}
//longTermMean bars
QColor seeThroughYellow = Qt::yellow;
seeThroughYellow.setAlpha(255);
QColor seeThroughGreen = Qt::green;
seeThroughGreen.setAlpha(255);
for(int j=0; j<rectIndex; j++) {
//if(isNoteRectEven[j]) p.setBrush(QBrush(Qt::yellow, Qt::Dense3Pattern));
//else p.setBrush(QBrush(Qt::green, Qt::Dense3Pattern));
if(isNoteRectEven[j]) p.setBrush(seeThroughYellow);
else p.setBrush(seeThroughGreen);
p.drawRect(noteRect[j]);
}
}
}
}
int main(int argc, char* argv[])
{
if(argc < 2){
ADDRESS = "localhost";
}else{
std::string line = argv[1];
int colon_pos = line.find(":");
if(colon_pos != std::string::npos){
ADDRESS = line.substr(0, colon_pos);
PORT = std::stoi(line.substr(colon_pos + 1, std::string::npos));
}else{
ADDRESS = line;
}
}
std::cout << ADDRESS << std::endl;
std::cout << PORT << std::endl;
//start ros thread
XInitThreads();
std::thread ros_thread(ros_stuff);
//Initialize OSC stuff
UdpTransmitSocket transmit_socket( IpEndpointName( ADDRESS.c_str(), PORT ) );
listener = new LRPacketListener();
//listener->registerStringCallback(nothing);
listener->registerTransportCallback(sync);
listener->registerPlaybackCallback(playbackChanged);
listener->registerClipUpdateCallback(loadClip);
receive_socket = new UdpListeningReceiveSocket(IpEndpointName( IpEndpointName::ANY_ADDRESS, PORT ), listener);
//Set up threads
std::thread listen_thread(listen);
//interupt quits
signal(SIGINT, [](int signum){std::cout << "okay" << std::endl; quit = true; receive_socket->Break(); receive_socket->AsynchronousBreak();});
//conductor
listener->registerTransportCallback(update_baton);
//SFML
sf::Font font;
if (!font.loadFromFile("Ubuntu-R.ttf"))
{
std::cout << "where's the font?" << std::endl;
}
play_shape.rotate(90);
play_shape.setPosition(700, 10);
play_shape.setFillColor(sf::Color::Green);
stop_shape.setPosition(700, 10);
stop_shape.setFillColor(sf::Color::Red);
for(int i = 0; i < 50; i++){
sf::CircleShape baton(8, 20);
sf::Color color(255, i*255/50, 0, 51*(i-50)*(i-50)/500);
baton.setFillColor(color);
baton.setPosition(400, 300);
baton_trail.push_back(baton);
}
// select the font
transport_text.setFont(font); // font is a sf::Font
time_text.setFont(font);
offset_text.setFont(font);
debug_text.setFont(font);
transport_text.setCharacterSize(24); // in pixels, not points!
time_text.setCharacterSize(24);
offset_text.setCharacterSize(24);
debug_text.setCharacterSize(24);
transport_text.setColor(sf::Color::White);
time_text.setColor(sf::Color::White);
offset_text.setColor(sf::Color::White);
debug_text.setColor(sf::Color::White);
transport_text.setPosition(10, 10);
time_text.setPosition(10, 40);
offset_text.setPosition(10, 70);
debug_text.setPosition(400, 70);
// set the string to display
transport_text.setString("Hello world");
time_text.setString("waiting...");
offset_text.setString("no offset");
//sfml window
sf::ContextSettings settings;
settings.antialiasingLevel = 8;
sf::RenderWindow window(sf::VideoMode(800, 600), "Terpsichore", sf::Style::Default, settings);
window.setVerticalSyncEnabled(true);
//request initial information
send("/terpsichore", (int)1, transmit_socket);
// run the program as long as the window is open
while (window.isOpen())
{
// check all the window's events that were triggered since the last iteration of the loop
sf::Event event;
while (window.pollEvent(event))
{
// "close requested" event: we close the window
if (event.type == sf::Event::Closed){
window.close();
quit = true;
receive_socket->Break();
receive_socket->AsynchronousBreak();
}
}
// clear the window with black color
window.clear(sf::Color::Black);
// draw everything here...
// draw the notes of the currently playing clips
double y = 100.0;
double scale = 50.0;
for(std::map<int, Clip*>::iterator clip_it = listener->clips.begin(); clip_it != listener->clips.end(); clip_it++){
Clip* c = clip_it->second;
for(std::multimap<Position, Note>::iterator note_it = c->notes.begin(); note_it != c->notes.end(); note_it++){
Position p = note_it->first;
Note n = note_it->second;
double x = p.toFloat(listener->transport.timeSignature) * scale + 10;
double w = n.duration * scale;
double h = n.pitch;
sf::RectangleShape noteRect(sf::Vector2f(w, h));
noteRect.setFillColor(sf::Color::Blue);
noteRect.setOutlineThickness(2);
noteRect.setOutlineColor(sf::Color::Cyan);
noteRect.setPosition(x, y);
window.draw(noteRect);
}
y += 80;
debug_text.setString(std::to_string(y));
}
// window.draw(...);
transport_text.setString(transport_string);
time_text.setString(time_string);
window.draw(time_text);
offset_text.setString(offset_string);
window.draw(offset_text);
window.draw(debug_text);
if(playing){
window.draw(play_shape);
}else{
window.draw(stop_shape);
}
//draw the baton point;
for(int i = baton_trail.size() - 1; i >= 0; i--){
window.draw(baton_trail.at(i));
}
window.draw(transport_text);
// end the current frame
window.display();
}
//stopping threads
std::cout << "attempting to join\n";
listen_thread.join();
ros_thread.join();
delete receive_socket;
delete listener;
return 0;
}
