void GraphicsSelectionItem::mouseMoveEvent(QGraphicsSceneMouseEvent *event)
{
if (m_isResizing)
{
qreal dx = event->pos().x() - rect().x();
qreal dy = event->pos().y() - rect().y();
prepareGeometryChange();
dx = qBound(MIN_ITEM_SIZE, dx, MAX_ITEM_SIZE);
dy = qBound(MIN_ITEM_SIZE, dy, MAX_ITEM_SIZE);
setRect(QRectF(rect().topLeft(), QSizeF(dx, dy)));
emit rectChanged(rect());
}
else if ((event->buttons() & Qt::LeftButton) == Qt::LeftButton)
{
prepareGeometryChange();
setRect(QRectF(rect().topLeft() + event->scenePos() - event->lastScenePos(), rect().size()));
emit rectChanged(rect());
}
else
{
QGraphicsItem::mouseMoveEvent(event);
}
}
void QViewport::setRect(const QRectF &rect)
{
Q_D(QViewport);
if (rect != d->m_rect) {
d->m_rect = rect;
emit rectChanged();
}
}
void SubtitleFilter::setRect(const QRectF &r)
{
DPTR_D(SubtitleFilter);
if (d.rect == r)
return;
d.rect = r;
emit rectChanged();
}
void HitBox::setRect(const QRectF &rect) {
if (m_rect == rect) {
return;
}
m_rect = rect;
emit rectChanged(rect);
}
/*!
* \brief ImageArea::mouseReleaseEvent
* \param e
*/
void ImageArea::mouseReleaseEvent(QMouseEvent* e)
{
if (e->button() == Qt::LeftButton) {
setX2(e->x());
setY2(e->y());
setX2(std::min(e->x(), ImageStorage::getInstance().getImageWidth() - 1));
setY2(std::min(e->y(), ImageStorage::getInstance().getImageHeight() - 1));
rectnotdrawing = true;
emit rectChanged(bounds);
update();
}
}
CanvasContainer::CanvasContainer(QWidget *parent) :
QGraphicsView(parent), proxy(0), scaleSliderWidget(0),
smoothScaleFlag(true)
{
setCacheMode(QGraphicsView::CacheBackground);
setAlignment(Qt::AlignTop | Qt::AlignLeft);
setTransformationAnchor(QGraphicsView::AnchorUnderMouse);
setResizeAnchor(QGraphicsView::AnchorUnderMouse);
scene = new QGraphicsScene(this);
setScene(scene);
auto rc = [&](){
emit rectChanged(visualRect().toRect());
};
connect(horizontalScrollBar(), &QScrollBar::valueChanged,
rc);
connect(verticalScrollBar(), &QScrollBar::valueChanged,
rc);
}
void CanvasContainer::setScaleFactor(qreal factor)
{
factor = qBound(MIN_SCALE_FACTOR, factor, MAX_SCALE_FACTOR);
if (proxy)
{
if (smoothScaleFlag)
{
if (factor < 1)
setRenderHints(QPainter::Antialiasing | QPainter::SmoothPixmapTransform);
else
{
setRenderHint(QPainter::Antialiasing, false);
setRenderHint(QPainter::SmoothPixmapTransform, false);
}
}
proxy->setScale(factor);
setSceneRect(scene->itemsBoundingRect());
emit scaled(factor);
emit rectChanged(visualRect().toRect());
}
}
void AnimationRect::_setRect(const sf::IntRect& rect) {
this->rect = rect;
emit rectChanged(rect);
}
/*!
* \brief Processor::run
*/
void VideoProcessor::run()
{
QVector<int> lightPixelsNumbers;
QVector<double> lightPixelsMeans;
QVector<double> timeStamps;
if(autodetection){
emit detection();
QRect rect = lightDetector->detectLight(filename, qMakePair(range.first, range.second));
if(stop){
stop = false;
return;
}
imageProcessor->setBounds(rect);
emit rectChanged(rect);
}
CaptureWrapper capture(filename);
try{
capture.isOpened();
int frameNumber = int(capture.get(CV_CAP_PROP_FRAME_COUNT));
int fps = Utils::Video::getAVIFPS(filename.toStdString());
lightDetector->fixRange(range, fps, frameNumber);
if(range.first >= range.second
&& range.first > std::numeric_limits<double>::epsilon()
&& range.second > std::numeric_limits<double>::epsilon()){
return;
}
int absIndex = 0;
for(int i = 0; i < int(range.first * fps); ++i, ++absIndex){
capture.grab();
}
cv::Mat frame;
for(int i = int(range.first * fps); i < int(range.second * fps); i++){
if (stop) {
stop = false;
break;
}
capture >> frame;
cv::Mat grayFrame;
cv::cvtColor(frame, grayFrame, CV_BGR2GRAY, 1);
cv::flip(grayFrame, grayFrame, 0);
QPair<int, double> processingResult;
if(imageProcessor){
imageProcessor->setH_size(QSize(640, 480));
processingResult = imageProcessor->process(grayFrame);
}else{
QMessageBox::critical(0, "Error", "No image processor is set!\nContact with developer!");
processingResult = qMakePair(0, 0.0l);
}
lightPixelsNumbers.push_back(processingResult.first);
lightPixelsMeans.push_back(processingResult.second);
absIndex++;
int relIndex = absIndex - int(range.first * fps);
const int hundreds = int((range.second - range.first) * fps) / 100;
if (hundreds && !(relIndex % (hundreds))) {
emit progress(relIndex / (hundreds));
}
double timestamp = absIndex / double(fps);
timeStamps.push_back(timestamp);
emit time(timestamp);
QThread::currentThread()->usleep(50);
}
std::shared_ptr<Results> results(new Results);
results->resultsNumbers = lightPixelsNumbers;
results->resultMeans = lightPixelsMeans;
results->timeStamps = timeStamps;
emit displayResults(results);
emit progress(100);
}
catch(CaptureError e){
QMessageBox::critical(0, "Error", e.getMessage());
return;
}
}
