Go back to Richel Bilderbeek's homepage.

Go back to Richel Bilderbeek's C++ page.

(C++) TestImageCanvas

TestImageCanvas is a tool to test the ImageCanvas class.

Downloads

Technical facts

Operating system(s) or programming environment(s)

Lubuntu 15.04 (vivid)

IDE(s):

Qt Creator 3.1.1

Project type:

Console application

C++ standard:

C++98

Compiler(s):

G++ 4.9.2

Libraries used:

STL: GNU ISO C++ Library, version 4.9.2

Qt project file: ./ToolTestImageCanvas/ToolTestImageCanvasConsole.pro


include(../../ConsoleApplication.pri)



include(../../Libraries/Boost.pri)



include(../../Classes/CppAbout/CppAbout.pri)

include(../../Classes/CppFileIo/CppFileIo.pri)

include(../../Classes/CppHelp/CppHelp.pri)

include(../../Classes/CppMenuDialog/CppMenuDialog.pri)

include(../../Classes/CppRichelBilderbeekProgram/CppRichelBilderbeekProgram.pri)

include(../../Classes/CppTrace/CppTrace.pri)



#Specific

include(../../Classes/CppCanvas/CppCanvas.pri)

#include(../../Classes/CppDotMatrix/CppDotMatrix.pri)

include(../../Tools/ToolTestImageCanvas/ToolTestImageCanvasConsole.pri)

include(../../Classes/CppImageCanvas/CppImageCanvas.pri)



SOURCES += main.cpp

Qt project file: ./ToolTestImageCanvas/ToolTestImageCanvasDesktop.pro


include(../../DesktopApplication.pri)

include(../../Libraries/Boost.pri)

include(../../Libraries/GeneralConsole.pri)

include(../../Libraries/GeneralDesktop.pri)



#Specific for this application

#Console

include(../../Classes/CppCanvas/CppCanvas.pri)

include(../../Classes/CppDotMatrix/CppDotMatrix.pri)

include(../../Classes/CppImageCanvas/CppImageCanvas.pri)

include(../../Classes/CppTextCanvas/CppTextCanvas.pri)

#Desktop

include(../../Classes/CppQtCanvas/CppQtCanvas.pri)



include(ToolTestImageCanvasDesktop.pri)



SOURCES += qtmain.cpp

Qt project file: ./ToolTestImageCanvas/ToolWebsite.pro


include(../../Tools/Tool/ToolConsole.pri)

./ToolTestImageCanvas/ToolTestImageCanvasConsole.pri


INCLUDEPATH += \

    ../../Tools/ToolTestImageCanvas



SOURCES += \

    ../../Tools/ToolTestImageCanvas/testimagecanvasmenudialog.cpp



HEADERS += \

    ../../Tools/ToolTestImageCanvas/testimagecanvasmenudialog.h



OTHER_FILES += \

    ../../Tools/ToolTestImageCanvas/Licence.txt



RESOURCES += \

    ../../Tools/ToolTestImageCanvas/ToolTestImageCanvas.qrc

./ToolTestImageCanvas/ToolTestImageCanvasDesktop.pri


include(../../Tools/ToolTestImageCanvas/ToolTestImageCanvasConsole.pri)



FORMS += \

    ../../Tools/ToolTestImageCanvas/qttestimagecanvasmenudialog.ui \

    ../../Tools/ToolTestImageCanvas/qttestimagecanvasmaindialog.ui



SOURCES += \

    ../../Tools/ToolTestImageCanvas/qttestimagecanvasmenudialog.cpp \

    ../../Tools/ToolTestImageCanvas/qttestimagecanvasmaindialog.cpp



HEADERS += \

    ../../Tools/ToolTestImageCanvas/qttestimagecanvasmenudialog.h \

    ../../Tools/ToolTestImageCanvas/qttestimagecanvasmaindialog.h

./ToolTestImageCanvas/ToolTestImageCanvasWebsite.pri


include(../../Tools/ToolTestImageCanvas/ToolTestImageCanvasConsole.pri)



SOURCES +=



HEADERS +=

./ToolTestImageCanvas/main.cpp


#include "testimagecanvasmenudialog.h"

#include "trace.h"



int main(int argc, char* argv[])

{

  START_TRACE();

  const std::vector<std::string> args { ribi::MenuDialog::ConvertArguments(argc,argv) };

  return ribi::TestImageCanvasMenuDialog().Execute(args);

}

./ToolTestImageCanvas/qtmain.cpp


#pragma GCC diagnostic push

#pragma GCC diagnostic ignored "-Weffc++"

#pragma GCC diagnostic ignored "-Wunused-local-typedefs"

#include <QApplication>



#include "qttestimagecanvasmenudialog.h"

#include "trace.h"

#pragma GCC diagnostic pop



int main(int argc, char *argv[])

{

  QApplication a(argc, argv);

  START_TRACE();

  ribi::QtTestImageCanvasMenuDialog d;

  d.show();

  return a.exec();

}

./ToolTestImageCanvas/qttestimagecanvasmaindialog.h


#ifndef QTTESTIMAGECANVASMAINDIALOG_H

#define QTTESTIMAGECANVASMAINDIALOG_H



#pragma GCC diagnostic push

#pragma GCC diagnostic ignored "-Weffc++"

#pragma GCC diagnostic ignored "-Wunused-local-typedefs"

#include <boost/shared_ptr.hpp>

#include "imagecanvas.h"

#include "canvascolorsystem.h"

#include "canvascoordinatsystem.h"

#include "qthideandshowdialog.h"

#pragma GCC diagnostic pop



namespace Ui {

  class QtTestImageCanvasMainDialog;

}



namespace ribi {



struct ImageCanvas;

struct QtCanvas;



class QtTestImageCanvasMainDialog : public QtHideAndShowDialog

{

  Q_OBJECT

  

public:

  explicit QtTestImageCanvasMainDialog(QWidget *parent = 0);

  QtTestImageCanvasMainDialog(const QtTestImageCanvasMainDialog&) = delete;

  QtTestImageCanvasMainDialog& operator=(const QtTestImageCanvasMainDialog&) = delete;

  ~QtTestImageCanvasMainDialog() noexcept;

  

private slots:



  void on_box_color_system_currentIndexChanged(int index);

  void on_box_coordinat_system_currentIndexChanged(int index);

  void on_button_image_clicked();



  void on_box_n_cols_valueChanged(int arg1);



private:

  Ui::QtTestImageCanvasMainDialog *ui;

  ImageCanvas m_canvas;

  QtCanvas * m_qtcanvas;



  static ImageCanvas CreateCanvas();



  CanvasColorSystem GetColorSystem() const noexcept;

  CanvasCoordinatSystem GetCoordinatSystem() const noexcept;

  int GetNcols() const noexcept;



  #ifndef NDEBUG

  static void Test() noexcept;

  #endif

};



} //~namespace ribi



#endif // QTTESTIMAGECANVASMAINDIALOG_H

./ToolTestImageCanvas/qttestimagecanvasmaindialog.cpp


#pragma GCC diagnostic push

#pragma GCC diagnostic ignored "-Weffc++"

#pragma GCC diagnostic ignored "-Wunused-local-typedefs"

#include "qttestimagecanvasmaindialog.h"



#include <cassert>

#include <sstream>



#include <boost/bind.hpp>

#include <boost/lambda/lambda.hpp>



#include "dotmatrixstring.h"

#include "fileio.h"

#include "imagecanvas.h"

#include "qtcanvas.h"

#include "testtimer.h"

#include "trace.h"

#include "ui_qttestimagecanvasmaindialog.h"

#pragma GCC diagnostic pop



ribi::QtTestImageCanvasMainDialog::QtTestImageCanvasMainDialog(QWidget *parent) :

  QtHideAndShowDialog(parent),

  ui(new Ui::QtTestImageCanvasMainDialog),

  m_canvas(CreateCanvas()),

  m_qtcanvas{new QtCanvas}

{

  #ifndef NDEBUG

  Test();

  #endif

  ui->setupUi(this);



  {

    assert(ui->verticalLayout);

    m_qtcanvas->SetImageCanvas(m_canvas);

    ui->verticalLayout->addWidget(m_qtcanvas);

  }

}



ribi::QtTestImageCanvasMainDialog::~QtTestImageCanvasMainDialog() noexcept

{

  delete ui;

}



ribi::ImageCanvas ribi::QtTestImageCanvasMainDialog::CreateCanvas()

{

  const int n_cols = 40;

  const std::string filename { fileio::FileIo().GetTempFileName() };

  QFile file(":/ToolTestImageCanvas/images/R.png");

  file.copy(filename.c_str());

  assert(fileio::FileIo().IsRegularFile(filename));

  ImageCanvas canvas(filename,n_cols);

  fileio::FileIo().DeleteFile(filename);

  assert(!fileio::FileIo().IsRegularFile(filename));

  return canvas;

}



ribi::CanvasColorSystem ribi::QtTestImageCanvasMainDialog::GetColorSystem() const noexcept

{

  const CanvasColorSystem color_system

    = ui->box_color_system->currentIndex() == 0

    ? CanvasColorSystem::normal

    : CanvasColorSystem::invert;

  return color_system;

}



ribi::CanvasCoordinatSystem ribi::QtTestImageCanvasMainDialog::GetCoordinatSystem() const noexcept

{

  const CanvasCoordinatSystem coordinat_system

    = ui->box_coordinat_system->currentIndex() == 0

    ? CanvasCoordinatSystem::screen

    : CanvasCoordinatSystem::graph;

  return coordinat_system;

}



int ribi::QtTestImageCanvasMainDialog::GetNcols() const noexcept

{

  return ui->box_n_cols->value();

}



void ribi::QtTestImageCanvasMainDialog::on_box_color_system_currentIndexChanged(int )

{

  this->m_canvas.SetColorSystem(GetColorSystem());

  //Should redraw automatically

}



void ribi::QtTestImageCanvasMainDialog::on_box_coordinat_system_currentIndexChanged(int )

{

  this->m_canvas.SetCoordinatSystem(GetCoordinatSystem());

  //Should redraw automatically

}



#ifndef NDEBUG

void ribi::QtTestImageCanvasMainDialog::Test() noexcept

{

  {

    static bool is_tested{false};

    if (is_tested) return;

    is_tested = true;

  }

  {

    DotMatrixString();

    ImageCanvas();

    TextCanvas();

  }

  const TestTimer test_timer(__func__,__FILE__,1.0);

  QtTestImageCanvasMainDialog d;

  d.on_button_image_clicked();

}

#endif



void ribi::QtTestImageCanvasMainDialog::on_button_image_clicked()

{

  QFile qfile(":/ToolTestImageCanvas/images/R.png");

  const std::string filename { fileio::FileIo().GetTempFileName() };

  qfile.copy(filename.c_str());

  assert(fileio::FileIo().IsRegularFile(filename));

  m_canvas = ImageCanvas(

    filename,

    GetNcols(),

    GetColorSystem(),

    GetCoordinatSystem()

  );

  delete m_qtcanvas;

  m_qtcanvas = new QtCanvas;

  m_qtcanvas->SetImageCanvas(m_canvas);

  ui->verticalLayout->addWidget(m_qtcanvas);



  fileio::FileIo().DeleteFile(filename);

  assert(!fileio::FileIo().IsRegularFile(filename));

}



void ribi::QtTestImageCanvasMainDialog::on_box_n_cols_valueChanged(int)

{

  on_button_image_clicked();

}

./ToolTestImageCanvas/qttestimagecanvasmenudialog.h


#ifndef QTTESTIMAGECANVASMENUDIALOG_H

#define QTTESTIMAGECANVASMENUDIALOG_H



#include "qthideandshowdialog.h"



namespace Ui {

  class QtTestImageCanvasMenuDialog;

}



namespace ribi {



class QtTestImageCanvasMenuDialog : public QtHideAndShowDialog

{

  Q_OBJECT



public:

  explicit QtTestImageCanvasMenuDialog(QWidget *parent = 0);

  QtTestImageCanvasMenuDialog(const QtTestImageCanvasMenuDialog&) = delete;

  QtTestImageCanvasMenuDialog& operator=(const QtTestImageCanvasMenuDialog&) = delete;

  ~QtTestImageCanvasMenuDialog() noexcept;



protected:

  void keyPressEvent(QKeyEvent * event);



private:

  Ui::QtTestImageCanvasMenuDialog *ui;



private slots:

  void on_button_about_clicked();

  void on_button_quit_clicked();

  void on_button_start_canvas_clicked();



  #ifndef NDEBUG

  static void Test() noexcept;

  #endif

};



} //~namespace ribi



#endif // QTTESTIMAGECANVASMENUDIALOG_H

./ToolTestImageCanvas/qttestimagecanvasmenudialog.cpp


#pragma GCC diagnostic push

#pragma GCC diagnostic ignored "-Weffc++"

#pragma GCC diagnostic ignored "-Wunused-local-typedefs"

#include "qttestimagecanvasmenudialog.h"



#include <QDesktopWidget>

#include <QKeyEvent>



#include "testimagecanvasmenudialog.h"

#include "qtaboutdialog.h"

#include "qttestimagecanvasmaindialog.h"

#include "qthideandshowdialog.h"

#include "testtimer.h"

#include "trace.h"

#include "ui_qttestimagecanvasmenudialog.h"

#pragma GCC diagnostic pop



ribi::QtTestImageCanvasMenuDialog::QtTestImageCanvasMenuDialog(

  QWidget *parent)

  : QtHideAndShowDialog(parent),

    ui(new Ui::QtTestImageCanvasMenuDialog)

{

  #ifndef NDEBUG

  Test();

  #endif

  ui->setupUi(this);

}



ribi::QtTestImageCanvasMenuDialog::~QtTestImageCanvasMenuDialog() noexcept

{

  delete ui;

}



void ribi::QtTestImageCanvasMenuDialog::keyPressEvent(QKeyEvent * event)

{

  if (event->key() == Qt::Key_Escape) { close(); return; }

}



void ribi::QtTestImageCanvasMenuDialog::on_button_about_clicked()

{

  About a = TestImageCanvasMenuDialog().GetAbout();

  a.AddLibrary("QtHideAndShowDialog version: " + QtHideAndShowDialog::GetVersion());

  QtAboutDialog d(a);

  d.setWindowIcon(this->windowIcon());

  d.setStyleSheet(this->styleSheet());

  this->ShowChild(&d);

}



void ribi::QtTestImageCanvasMenuDialog::on_button_quit_clicked()

{

  close();

}



void ribi::QtTestImageCanvasMenuDialog::on_button_start_canvas_clicked()

{

  QtTestImageCanvasMainDialog d;

  d.setWindowIcon(this->windowIcon());

  //d.setStyleSheet(this->styleSheet());

  ShowChild(&d);

}



#ifndef NDEBUG

void ribi::QtTestImageCanvasMenuDialog::Test() noexcept

{

  {

    static bool is_tested{false};

    if (is_tested) return;

    is_tested = true;

  }

  QtTestImageCanvasMainDialog();

  const TestTimer test_timer(__func__,__FILE__,1.0);

}

#endif

./ToolTestImageCanvas/testimagecanvasmenudialog.h


#ifndef TESTIMAGECANVASMENUDIALOG_H

#define TESTIMAGECANVASMENUDIALOG_H



#include "menudialog.h"



namespace ribi {



///GUI independent TestImageCanvas menu dialog

struct TestImageCanvasMenuDialog final : public MenuDialog

{

  About GetAbout() const noexcept override;

  Help GetHelp() const noexcept override;

  boost::shared_ptr<const Program> GetProgram() const noexcept override;

  std::string GetVersion() const noexcept override;

  std::vector<std::string> GetVersionHistory() const noexcept override;



  private:

  int ExecuteSpecific(const std::vector<std::string>& argv) noexcept override;



  #ifndef NDEBUG

  static void Test() noexcept;

  #endif

};



} //~namespace ribi



#endif // TESTIMAGECANVASMENUDIALOG_H

./ToolTestImageCanvas/testimagecanvasmenudialog.cpp


#include "testimagecanvasmenudialog.h"



#include <cassert>

#include <fstream>

#include <iostream>



#pragma GCC diagnostic push

#pragma GCC diagnostic ignored "-Weffc++"

#pragma GCC diagnostic ignored "-Wunused-local-typedefs"

#include <boost/lexical_cast.hpp>

#include <boost/scoped_ptr.hpp>

#include <QFile>



#include "fileio.h"

#include "imagecanvas.h"

#include "richelbilderbeekprogram.h"

#include "trace.h"

#include "testtimer.h"

#pragma GCC diagnostic pop



int ribi::TestImageCanvasMenuDialog::ExecuteSpecific(const std::vector<std::string>& argv) noexcept

{

  #ifndef NDEBUG

  Test();

  #endif

  const int argc = static_cast<int>(argv.size());

  if (argc != 3 || argc != 4)

  {

    std::cout << GetHelp() << '\n';

    return 1;

  }

  {

    const std::string s { argv[1] };

    if (!fileio::FileIo().IsRegularFile(s))

    {

      std::cout

        << "Error: '" << s << "' is not found.\n"

        << "Please supply an existing file as "

        << GetAbout().GetFileTitle()

        << " its first argument\n";

      return 1;

    }

  }

  if (argc == 4)

  {

    const std::string s { argv[3] };

    try

    {

      const int n_cols = boost::lexical_cast<int>(s);

      if (n_cols < 5)

      {

        std::cout

          << "Error: the number of columns must be at least 5.\n"

          << "Please supply a number above 5 as "

          << GetAbout().GetFileTitle()

          << " its third argument\n";

        return 1;

      }

    }

    catch (boost::bad_lexical_cast&)

    {

      std::cout

        << "Error: '" << s << "' is not an integer number.\n"

        << "Please supply a number as"

        << GetAbout().GetFileTitle()

        << " AsciiArter its third argument\n";

      return 1;



    }

  }



  assert(argc >= 3);

  const std::string from_name { argv[1] };

  std::string to_name { argv[2] };

  const int n_cols = (argc == 4 ? boost::lexical_cast<int>(argv[3]) : 78);



  const boost::shared_ptr<const ImageCanvas> d {

    new ImageCanvas(from_name,n_cols)

  };

  //const std::vector<std::string> v { d.GetAsciiArt() };

  std::ofstream f(to_name.c_str());

  f << (*d);

  //std::copy(v.begin(),v.end(),std::ostream_iterator<std::string>(f,"\n"));

  return 0;

}



ribi::About ribi::TestImageCanvasMenuDialog::GetAbout() const noexcept

{

  About a(

    "Richel Bilderbeek",

    "TestImageCanvas",

    "tests the ImageCanvas class",

    "the 9th of January 2014",

    "2014-2015",

    "http://www.richelbilderbeek.nl/TooTestImageCanvas.htm",

    GetVersion(),

    GetVersionHistory());

  a.AddLibrary("Canvas version: " + Canvas::GetVersion());

  a.AddLibrary("ImageCanvas version: " + ImageCanvas::GetVersion());

  a.AddLibrary("Trace version: " + Trace::GetVersion());

  return a;

}



ribi::Help ribi::TestImageCanvasMenuDialog::GetHelp() const noexcept

{

  return Help(

    this->GetAbout().GetFileTitle(),

    this->GetAbout().GetFileDescription(),

    {



    },

    {



    }

  );

}



boost::shared_ptr<const ribi::Program> ribi::TestImageCanvasMenuDialog::GetProgram() const noexcept

{

  const boost::shared_ptr<const Program> p {

    new ProgramTestImageCanvas

  };

  assert(p);

  return p;

}



std::string ribi::TestImageCanvasMenuDialog::GetVersion() const noexcept

{

  return "1.0";

}



std::vector<std::string> ribi::TestImageCanvasMenuDialog::GetVersionHistory() const noexcept

{

  return {

    "2014-01-09: version 1.0: initial version"

  };

}



#ifndef NDEBUG

void ribi::TestImageCanvasMenuDialog::Test() noexcept

{

  {

    static bool is_tested{false};

    if (is_tested) return;

    is_tested = true;

  }

  const TestTimer test_timer(__func__,__FILE__,1.0);

  {

    const std::string temp_filename { fileio::FileIo().GetTempFileName() };

    {

      const std::string resource_filename { ":/CppImageCanvas/images/R.png" };

      QFile qfile(resource_filename.c_str());

      qfile.copy(temp_filename.c_str());

      if (!fileio::FileIo().IsRegularFile(temp_filename))

      {

        TRACE("ERROR");

        TRACE(resource_filename);

        TRACE("Resource filename must exist");

      }

    }

    assert(fileio::FileIo().IsRegularFile(temp_filename));

    for (int i=0; i!=4; ++i)

    {

      const CanvasColorSystem color_system

        = i / 2 ? CanvasColorSystem::invert : CanvasColorSystem::normal;

      const CanvasCoordinatSystem coordinat_system

        = i % 2 ? CanvasCoordinatSystem::graph : CanvasCoordinatSystem::screen;

      const boost::shared_ptr<const ImageCanvas> c {

        new ImageCanvas(temp_filename,20,color_system,coordinat_system)

      };

      std::stringstream s;

      s << (*c);

      TRACE(s.str());

      assert(!s.str().empty());

    }

    fileio::FileIo().DeleteFile(temp_filename);

  }

}

#endif

Go back to Richel Bilderbeek's C++ page.

Go back to Richel Bilderbeek's homepage.

This page has been created by the tool CodeToHtml