Changeset - f7670384fcb0
Parent rev.
Child rev.
[Not reviewed]
value-tracker
0 14 0
Hasan Yavuz ÖZDERYA - 7 years ago 2018-12-12 15:05:26
hy@ozderya.net
added linear index buffer to support scaled x axis

this is also an important step towards "x data" support
14 files changed with 147 insertions and 75 deletions:
CMakeLists.txt
1
src/framebufferseries.cpp
29
40
src/framebufferseries.h
4
7
src/linindexbuffer.cpp
16
2
src/linindexbuffer.h
7
5
src/mainwindow.cpp
6
src/plotmanager.cpp
9
8
src/plotmanager.h
1
1
src/snapshot.h
3
1
src/snapshotmanager.cpp
2
src/stream.cpp
37
2
src/stream.h
12
3
tests/test.cpp
8
tests/test_stream.cpp
12
6
0 comments (0 inline, 0 general)
CMakeLists.txt
➞
Show inline comments
 
#
 
# Copyright © 2018 Hasan Yavuz Özderya
 
#
 
# This file is part of serialplot.
 
#
 
# serialplot is free software: you can redistribute it and/or modify
 
# it under the terms of the GNU General Public License as published by
 
# the Free Software Foundation, either version 3 of the License, or
 
# (at your option) any later version.
 
#
 
# serialplot is distributed in the hope that it will be useful,
 
# but WITHOUT ANY WARRANTY; without even the implied warranty of
 
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
# GNU General Public License for more details.
 
#
 
# You should have received a copy of the GNU General Public License
 
# along with serialplot.  If not, see <http://www.gnu.org/licenses/>.
 
#
 

			




	
	
	
		
 
cmake_minimum_required(VERSION 3.2.2)

			




	
	
	
		
 

			




	
	
	
		
 
project(serialplot)

			




	
	
	
		
 

			




	
	
	
		
 
set(PROGRAM_NAME ${CMAKE_PROJECT_NAME} CACHE STRING "Output program name")

			




	
	
	
		
 
set(PROGRAM_DISPLAY_NAME "SerialPlot" CACHE STRING "Display name (menus etc) of the program")

			




	
	
	
		
 

			




	
	
	
		
 
# Find includes in corresponding build directories

			




	
	
	
		
 
set(CMAKE_INCLUDE_CURRENT_DIR ON)

			




	
	
	
		
 

			




	
	
	
		
 
# Instruct CMake to run moc automatically when needed.

			




	
	
	
		
 
set(CMAKE_AUTOMOC ON)

			




	
	
	
		
 

			




	
	
	
		
 
# add local path for cmake modules

			




	
	
	
		
 
set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} "${CMAKE_SOURCE_DIR}/cmake/modules/")

			




	
	
	
		
 

			




	
	
	
		
 
# Find the QtWidgets library

			




	
	
	
		
 
find_package(Qt5Widgets)

			




	
	
	
		
 

			




	
	
	
		
 
# If set, cmake will download Qwt over SVN, build and use it as a static library.

			




	
	
	
		
 
set(BUILD_QWT true CACHE BOOL "Download and build Qwt automatically.")

			




	
	
	
		
 
if (BUILD_QWT)

			




	
	
	
		
 
  include(BuildQwt)

			




	
	
	
		
 
else (BUILD_QWT)

			




	
	
	
		
 
    find_package(Qwt 6.1 REQUIRED)

			




	
	
	
		
 
endif (BUILD_QWT)

			




	
	
	
		
 

			




	
	
	
		
 
# If set, cmake will download QtColorWidgets over git, build and use it as a static library.

			




	
	
	
		
 
set(BUILD_QTCOLORWIDGETS true CACHE BOOL "Download and build QtColorWidgets library automatically.")

			




	
	
	
		
 
if (BUILD_QTCOLORWIDGETS)

			




	
	
	
		
 
  include(BuildQColorWidgets)

			




	
	
	
		
 
else ()

			




	
	
	
		
 
  find_package(QtColorWidgets REQUIRED)

			




	
	
	
		
 
endif ()

			




	
	
	
		
 

			




	
	
	
		
 
set(BUILD_LEDWIDGET true CACHE BOOL "Download and build LedWidget automatically.")

			




	
	
	
		
 
if (BUILD_LEDWIDGET)

			




	
	
	
		
 
  include(BuildLedWidget)

			




	
	
	
		
 
else (BUILD_LEDWIDGET)

			




	
	
	
		
 
  include(FindLedWidget)

			




	
	
	
		
 
endif (BUILD_LEDWIDGET)

			




	
	
	
		
 

			




	
	
	
		
 
# includes

			




	
	
	
		
 
include_directories("./src"

			




	
	
	
		
 
  ${QWT_INCLUDE_DIR}

			




	
	
	
		
 
  ${QTCOLORWIDGETS_INCLUDE_DIRS}

			




	
	
	
		
 
  ${LEDWIDGET_INCLUDE_DIR}

			




	
	
	
		
 
  )

			




	
	
	
		
 

			




	
	
	
		
 
# flags

			




	
	
	
		
 
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${QTCOLORWIDGETS_FLAGS}")

			




	
	
	
		
 

			




	
	
	
		
 
# wrap UI and resource files

			




	
	
	
		
 
qt5_wrap_ui(UI_FILES

			




	
	
	
		
 
  src/mainwindow.ui

			




	
	
	
		
 
  src/portcontrol.ui

			




	
	
	
		
 
  src/about_dialog.ui

			




	
	
	
		
 
  src/snapshotview.ui

			




	
	
	
		
 
  src/commandpanel.ui

			




	
	
	
		
 
  src/commandwidget.ui

			




	
	
	
		
 
  src/dataformatpanel.ui

			




	
	
	
		
 
  src/plotcontrolpanel.ui

			




	
	
	
		
 
  src/recordpanel.ui

			




	
	
	
		
 
  src/numberformatbox.ui

			




	
	
	
		
 
  src/endiannessbox.ui

			




	
	
	
		
 
  src/binarystreamreadersettings.ui

			




	
	
	
		
 
  src/asciireadersettings.ui

			




	
	
	
		
 
  src/framedreadersettings.ui

			




	
	
	
		
 
  src/demoreadersettings.ui

			




	
	
	
		
 
  src/updatecheckdialog.ui

			




	
	
	
		
 
  )

			




	
	
	
		
 

			




	
	
	
		
 
if (WIN32)

			




	
	
	
		
 
  qt5_add_resources(RES_FILES misc/icons.qrc misc/winicons.qrc)

			




	
	
	
		
 
else (WIN32)

			




	
	
	
		
 
  qt5_add_resources(RES_FILES misc/icons.qrc)

			




	
	
	
		
 
endif (WIN32)

			




	
	
	
		
 

			




	
	
	
		
 
add_executable(${PROGRAM_NAME} WIN32

			




	
	
	
		
 
  src/main.cpp

			




	
	
	
		
 
  src/mainwindow.cpp

			




	
	
	
		
 
  src/portcontrol.cpp

			




	
	
	
		
 
  src/plot.cpp

			




	
	
	
		
 
  src/zoomer.cpp

			




	
	
	
		
 
  src/scrollzoomer.cpp

			




	
	
	
		
 
  src/scrollbar.cpp

			




	
	
	
		
 
  src/hidabletabwidget.cpp

			




	
	
	
		
 
  src/scalepicker.cpp

			




	
	
	
		
 
  src/scalezoomer.cpp

			




	
	
	
		
 
  src/portlist.cpp

			




	
	
	
		
 
  src/snapshot.cpp

			




	
	
	
		
 
  src/snapshotview.cpp

			




	
	
	
		
 
  src/snapshotmanager.cpp

			




	
	
	
		
 
  src/plotsnapshotoverlay.cpp

			




	
	
	
		
 
  src/commandpanel.cpp

			




	
	
	
		
 
  src/commandwidget.cpp

			




	
	
	
		
 
  src/commandedit.cpp

			




	
	
	
		
 
  src/dataformatpanel.cpp

			




	
	
	
		
 
  src/plotcontrolpanel.cpp

			




	
	
	
		
 
  src/recordpanel.cpp

			




	
	
	
		
 
  src/datarecorder.cpp

			




	
	
	
		
 
  src/tooltipfilter.cpp

			




	
	
	
		
 
  src/sneakylineedit.cpp

			




	
	
	
		
 
  src/stream.cpp

			




	
	
	
		
 
  src/streamchannel.cpp

			




	
	
	
		
 
  src/channelinfomodel.cpp

			




	
	
	
		
 
  src/ringbuffer.cpp

			




	
	
	
		
 
  src/ringbuffer.cpp

			




	
	
	
		
 
  src/indexbuffer.cpp

			




	
	
	
		
 
  src/linindexbuffer.cpp

			




	
	
	
		
 
  src/readonlybuffer.cpp

			




	
	
	
		
 
  src/framebufferseries.cpp

			




	
	
	
		
 
  src/numberformatbox.cpp

			




	
	
	
		
 
  src/endiannessbox.cpp

			




	
	
	
		
 
  src/abstractreader.cpp

			




	
	
	
		
 
  src/binarystreamreader.cpp

			




	
	
	
		
 
  src/binarystreamreadersettings.cpp

			




	
	
	
		
 
  src/asciireader.cpp

			




	
	
	
		
 
  src/asciireadersettings.cpp

			




	
	
	
		
 
  src/demoreader.cpp

			




	
	
	
		
 
  src/demoreadersettings.cpp

			




	
	
	
		
 
  src/framedreader.cpp

			




	
	
	
		
 
  src/framedreadersettings.cpp

			




	
	
	
		
 
  src/plotmanager.cpp

			




	
	
	
		
 
  src/plotmenu.cpp

			




	
	
	
		
 
  src/barplot.cpp

			




	
	
	
		
 
  src/barchart.cpp

			




	
	
	
		
 
  src/barscaledraw.cpp

			




	
	
	
		
 
  src/numberformat.cpp

			




	
	
	
		
 
  src/updatechecker.cpp

			




	
	
	
		
 
  src/versionnumber.cpp

			




	
	
	
		
 
  src/updatecheckdialog.cpp

			




	
	
	
		
 
  src/samplepack.cpp

			




	
	
	
		
 
  src/source.cpp

			




	
	
	
		
 
  src/sink.cpp

			




	
	
	
		
 
  src/samplecounter.cpp

			




	
	
	
		
 
  misc/windows_icon.rc

			




	
	
	
		
 
  ${UI_FILES}

			




	
	
	
		
 
  ${RES_FILES}

			




	
	
	
		
 
  )

			




	
	
	
		
 

			




	
	
	
		
 
# Use the Widgets module from Qt 5.

			




	
	
	
		
 
target_link_libraries(${PROGRAM_NAME}

			




	
	
	
		
 
  ${QWT_LIBRARY}

			




	
	
	
		
 
  ${QTCOLORWIDGETS_LIBRARIES}

			




	
	
	
		
 
  ${LEDWIDGET_LIBRARY}

			




	
	
	
		
 
  )

			




	
	
	
		
 
qt5_use_modules(${PROGRAM_NAME} Widgets SerialPort Network)

			




	
	
	
		
 

			




	
	
	
		
 
if (BUILD_QWT)

			




	
	
	
		
 
  add_dependencies(${PROGRAM_NAME} QWT)

			




	
	
	
		
 
endif ()

			




	
	
	
		
 

			




	
	
	
		
 
if (BUILD_QTCOLORWIDGETS)

			




	
	
	
		
 
  add_dependencies(${PROGRAM_NAME} QCW)

			




	
	
	
		
 
endif ()

			




	
	
	
		
 

			




	
	
	
		
 
if (BUILD_LEDWIDGET)

			




	
	
	
		
 
  add_dependencies(${PROGRAM_NAME} LEDW)

			




	
	
	
		
 
endif (BUILD_LEDWIDGET)

			




	
	
	
		
 

			




	
	
	
		
 

			




	
	
	
		
 
# set compiler flags

			




	
	
	
		
 
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall")

			




	
	
	
		
 

			




	
	
	
		
 
# Enable C++11 support, fail if not supported

			




	
	
	
		
 
include(CheckCXXCompilerFlag)

			




	
	
	
		
 
CHECK_CXX_COMPILER_FLAG("-std=c++11" COMPILER_SUPPORTS_CXX11)

			




	
	
	
		
 
CHECK_CXX_COMPILER_FLAG("-std=c++0x" COMPILER_SUPPORTS_CXX0X)

			




	
	
	
		
 
if(COMPILER_SUPPORTS_CXX11)

			




	
	
	
		
 
  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++11")

			




	
	
	
		
 
elseif(COMPILER_SUPPORTS_CXX0X)

			




	
	
	
		
 
  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++0x")

			




	
	
	
		
 
else()

			




	
	
	
		
 
  message(STATUS "The compiler ${CMAKE_CXX_COMPILER} has no C++11 support. Please use a different C++ compiler.")

			




	
	
	
		
 
endif()

			




	
	
	
		
 

			




	
	
	
		
 
# default version

			




	
	
	
		
 
set(VERSION_STRING "0.10.0")

			




	
	
	
		
 
set(VERSION_REVISION "0")

			




	
	
	
		
 

			




	
	
	
		
 
# get revision number from mercurial and parse version string

			




	
	
	
		
 
include(GetVersion)

			




	
	
	
		
 

			




	
	
	
		
 
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -DVERSION_STRING=\\\"${VERSION_STRING}\\\" ")

			




	
	
	
		
 
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -DVERSION_MAJOR=${VERSION_MAJOR} ")

			




	
	
	
		
 
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -DVERSION_MINOR=${VERSION_MINOR} ")

			




	
	
	
		
 
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -DVERSION_PATCH=${VERSION_PATCH} ")

			




	
	
	
		
 
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -DVERSION_REVISION=\\\"${VERSION_REVISION}\\\" ")

			




	
	
	
		
 

			




	
	
	
		
 
# add make run target

			




	
	
	
		
 
add_custom_target(run

			




	
	
	
		
 
    COMMAND ${PROGRAM_NAME}

			




	
	
	
		
 
    DEPENDS ${PROGRAM_NAME}

			




	
	
	
		
 
    WORKING_DIRECTORY ${CMAKE_PROJECT_DIR}

			




	
	
	
		
 
)

			




	
	
	
		
 

			




	
	
	
		
 
# installing

			




	
	
	
		
 
install(TARGETS ${PROGRAM_NAME} DESTINATION bin)

			




	
	
	
		
 

			




	
	
	
		
 
# for windows put libraries to install directory

			




	
	
	
		
 
if (WIN32)

			




	
	
	
		
 
  file(GLOB WINDOWS_INSTALL_LIBRARIES

			




	
	
	
		
 
    "${CMAKE_BINARY_DIR}/windows_install_libraries/*.*")

			




	
	
	
		
 
  install(FILES ${WINDOWS_INSTALL_LIBRARIES} DESTINATION bin)

			




	
	
	
		
 
endif (WIN32)

			




	
	
	
		
 

			




	
	
	
		
 
# prepare menu item and icon

			




	
	
	
		
 
configure_file("${CMAKE_CURRENT_SOURCE_DIR}/misc/program_name.desktop.in"

			




	
	
	
		
 
  "${CMAKE_BINARY_DIR}/${PROGRAM_NAME}.desktop")

			




	
	
	
		
 
configure_file("${CMAKE_CURRENT_SOURCE_DIR}/misc/program_name.png"

			




	
	
	
		
 
  "${CMAKE_BINARY_DIR}/${PROGRAM_NAME}.png" COPYONLY)

			




	
	
	
		
 

			




	
	
	
		
 
set(DESKTOP_FILE ${CMAKE_BINARY_DIR}/${PROGRAM_NAME}.desktop)

			




	
	
	
		
 
set(ICON_FILE ${CMAKE_BINARY_DIR}/${PROGRAM_NAME}.png)

			




	
	
	
		
 

			




	
	
	
		
 
# install menu item and icon

			




	
	
	
		
 
if (UNIX)

			




	
	
	
		
 
  install(FILES ${DESKTOP_FILE} DESTINATION share/applications/)

			




	
	
	
		
 
  install(FILES ${ICON_FILE} DESTINATION share/icons/hicolor/256x256/apps/)

			




	
	
	
		
 
endif (UNIX)

			




	
	
	
		
 

			




	
	
	
		
 
# uninstalling

			




	
	
	
		
 
configure_file(

			




	
	
	
		
 
  "${CMAKE_CURRENT_SOURCE_DIR}/cmake/cmake_uninstall.cmake.in"

			




	
	
	
		
 
  "${CMAKE_CURRENT_BINARY_DIR}/cmake_uninstall.cmake"

			




	
	
	
		
 
  @ONLY)

			




	
	
	
		
 

			




	
	
	
		
 
if (UNIX)

			




	
	
	
		
 
  add_custom_target(uninstall

			




	
	
	
		
 
    COMMAND ${CMAKE_COMMAND} -P ${CMAKE_CURRENT_BINARY_DIR}/cmake_uninstall.cmake)

			




	
	
	
		
 
endif (UNIX)

			




	
	
	
		
 

			




	
	
	
		
 
# testing

			




	
	
	
		
 
set(ENABLE_TESTS false CACHE BOOL "Build tests.")

			




	
	
	
		
 
if (ENABLE_TESTS)

			




	
	
	
		
 
  enable_testing()

			




	
	
	
		
 
  add_subdirectory(tests)

			




	
	
	
		
 
endif ()

			




	
	
	
		
 

			




	
	
	
		
 
# packaging

			




	
	
	
		
 
include(BuildLinuxAppImage)

			




	
	
	
		
 

			




	
	
	
		
 
if (UNIX)

			




	
	
	
		
 
  set(CPACK_GENERATOR "DEB")

			




	
	
	
		
 
elseif (WIN32)

			




	
	
	
		
 
  set(CPACK_GENERATOR "NSIS")

			




	
	
	
		
 
endif (UNIX)

			




	
	
	
		
 

			




	
	
	
		
 
include(InstallRequiredSystemLibraries)

			




	
	
	
		
 

			




	
	
	
		
 
set(CPACK_PACKAGE_NAME "${PROGRAM_NAME}")

			




	
	
	
		
 
set(CPACK_PACKAGE_DESCRIPTION_SUMMARY "Small and simple software for plotting data from serial port")

			




	
	
	
		
 
set(CPACK_PACKAGE_CONTACT "Hasan Yavuz Özderya <hy@ozderya.net>")

			




	
	
	
		
 
set(CPACK_PACKAGE_VERSION_MAJOR ${VERSION_MAJOR})

			




	
	
	
		
 
set(CPACK_PACKAGE_VERSION_MINOR ${VERSION_MINOR})

			




	
	
	
		
 
set(CPACK_PACKAGE_VERSION_PATCH ${VERSION_PATCH})

			




	
	
	
		
 
set(CPACK_STRIP_FILES TRUE)

			




	
	
	
		
 
set(CPACK_DEBIAN_PACKAGE_DEPENDS "libqt5widgets5 (>= 5.2.1), libqt5svg5 (>= 5.2.1), libqt5serialport5 (>= 5.2.1), libc6 (>= 2.19)")

			




	
	
	
		
 
set(CPACK_DEBIAN_PACKAGE_DESCRIPTION "Small and simple software for plotting data from serial port

			




	
	
	
		
 
 Supports binary data formats ([u]int8, [u]int16, [u]int32, float)

			




	
	
	
		
 
 and ASCII (as CSV). Captured waveforms can be exported in CSV format.

			




	
	
	
		
 
 Can also send simple user defined commands to serial port device.")

			




	
	
	
		
 

			




	
	
	
		
 
if (NOT QWT_USE_STATIC)

			




	
	
	
		
 
  set(CPACK_DEBIAN_PACKAGE_DEPENDS "${CPACK_DEBIAN_PACKAGE_DEPENDS}, libqwt6-qt5 (>= 6.1.1)")

			




	
	
	
		
 
endif (NOT QWT_USE_STATIC)

			




	
	
	
		
 

			




	
	
	
		
 
if (UNIX)

			




	
	
	
		
 
  set(CPACK_PACKAGE_EXECUTABLES "${PROGRAM_NAME}")

			




	
	
	
		
 
elseif (WIN32)

			




	
	
	
		
 
  set(CPACK_PACKAGE_EXECUTABLES "${PROGRAM_NAME};${PROGRAM_DISPLAY_NAME}")

			




	
	
	
		
 
  set(CPACK_PACKAGE_INSTALL_DIRECTORY "${PROGRAM_NAME}")

			




	
	
	
		
 
  set(CPACK_CREATE_DESKTOP_LINKS "${PROGRAM_NAME}")

			




	
	
	
		
 
  set(CPACK_NSIS_MODIFY_PATH "ON")

			




	
	
	
		
 
  set(CPACK_PACKAGE_ICON "${CMAKE_SOURCE_DIR}/misc/serialplot.bmp")

			




	
	
	
		
 
  string(REPLACE "/" "\\\\" CPACK_PACKAGE_ICON ${CPACK_PACKAGE_ICON})

			




	
	
	
		
 
  set(CPACK_RESOURCE_FILE_LICENSE "${CMAKE_SOURCE_DIR}/COPYING")

			




	
	
	
		
 
  set(CPACK_NSIS_MENU_LINKS

			




	
	
	
		
 
    "https://bitbucket.org/hyOzd/serialplot" "SerialPlot source code on bitbucket.org")

			




	
	
	
		
 
  set(CPACK_NSIS_ENABLE_UNINSTALL_BEFORE_INSTALL true)

			




	
	
	
		
 
endif (UNIX)

			




	
	
	
		
 

			




	
	
	
		
 
if (UNIX)

			




	
	
	
		
 
  # set debian package name

			




	
	
	
		
 
  string(TOLOWER "${CPACK_PACKAGE_NAME}" CPACK_PACKAGE_NAME_LOWERCASE)

			




	
	
	
		
 
  find_program(DPKG_PROGRAM dpkg DOC "dpkg program of Debian-based systems")

			




	
	
	
		
 
  if(DPKG_PROGRAM)

			




	
	
	
		
 
    execute_process(

			




	
	
	
		
 
      COMMAND ${DPKG_PROGRAM} --print-architecture

			




	
	
	
		
 
      OUTPUT_VARIABLE CPACK_DEBIAN_PACKAGE_ARCHITECTURE

			




	
	
	
		
 
      OUTPUT_STRIP_TRAILING_WHITESPACE)

			




	
	
	
		
 
    set(CPACK_PACKAGE_FILE_NAME

			




	
	
	
		
 
      "${CPACK_PACKAGE_NAME_LOWERCASE}_${CPACK_PACKAGE_VERSION_MAJOR}.${CPACK_PACKAGE_VERSION_MINOR}.${CPACK_PACKAGE_VERSION_PATCH}_${CPACK_DEBIAN_PACKAGE_ARCHITECTURE}")

			




	
	
	
		
 
  else(DPKG_PROGRAM)

			




	
	
	
		
 
    set(CPACK_PACKAGE_FILE_NAME

			




	
	
	
		
 
      "${CPACK_PACKAGE_NAME_LOWERCASE}_${PROJECT_VERSION}-${PROJECT_VERSION_REVISION}_${CMAKE_SYSTEM_NAME}")

			




	
	
	
		
 
  endif(DPKG_PROGRAM)

			




	
	
	
		
 
endif (UNIX)

			




	
	
	
		
 

			




	
	
	
		
 
include(CPack)

			




        

    


    
    

    

        

                

                    src/framebufferseries.cpp
                

                

                  
                      
                        

                      ➞

                      
                        
                  

                  
                      
                  
                      
                  
                      
                  
                      
                  
                  
                

                

                    Show inline comments
                    
                

        

        

            



	
	
	
		
 
/*

			




	
	
	
		
 
  Copyright © 2018 Hasan Yavuz Özderya

			




	
	
	
		
 

			




	
	
	
		
 
  This file is part of serialplot.

			




	
	
	
		
 

			




	
	
	
		
 
  serialplot is free software: you can redistribute it and/or modify

			




	
	
	
		
 
  it under the terms of the GNU General Public License as published by

			




	
	
	
		
 
  the Free Software Foundation, either version 3 of the License, or

			




	
	
	
		
 
  (at your option) any later version.

			




	
	
	
		
 

			




	
	
	
		
 
  serialplot is distributed in the hope that it will be useful,

			




	
	
	
		
 
  but WITHOUT ANY WARRANTY; without even the implied warranty of

			




	
	
	
		
 
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

			




	
	
	
		
 
  GNU General Public License for more details.

			




	
	
	
		
 

			




	
	
	
		
 
  You should have received a copy of the GNU General Public License

			




	
	
	
		
 
  along with serialplot.  If not, see <http://www.gnu.org/licenses/>.

			




	
	
	
		
 
*/

			




	
	
	
		
 

			




	
	
	
		
 
#include <math.h>

			




	
	
	
		
 
#include "framebufferseries.h"

			




	
	
	
		
 

			




	
	
	
		
 
FrameBufferSeries::FrameBufferSeries(const FrameBuffer* buffer)

			




	
	
	
		
 
FrameBufferSeries::FrameBufferSeries(const XFrameBuffer* x, const FrameBuffer* y)

			




	
	
	
		
 
{

			




	
	
	
		
 
    xAsIndex = true;

			




	
	
	
		
 
    _xmin = 0;

			




	
	
	
		
 
    _xmax = 1;

			




	
	
	
		
 
    _buffer = buffer;

			




	
	
	
		
 
    _x = x;

			




	
	
	
		
 
    _y = y;

			




	
	
	
		
 

			




	
	
	
		
 
    int_index_start = 0;

			




	
	
	
		
 
    int_index_end = _buffer->size();

			




	
	
	
		
 
    int_index_end = _y->size();

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
void FrameBufferSeries::setXAxis(bool asIndex, double xmin, double xmax)

			




	
	
	
		
 
void FrameBufferSeries::setX(const XFrameBuffer* x)

			




	
	
	
		
 
{

			




	
	
	
		
 
    xAsIndex = asIndex;

			




	
	
	
		
 
    _xmin = xmin;

			




	
	
	
		
 
    _xmax = xmax;

			




	
	
	
		
 
    _x = x;

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
size_t FrameBufferSeries::size() const

			




	
	
	
		
 
{

			




	
	
	
		
 
    return int_index_end - int_index_start;

			




	
	
	
		
 
    return int_index_end - int_index_start + 1;

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
QPointF FrameBufferSeries::sample(size_t i) const

			




	
	
	
		
 
{

			




	
	
	
		
 
    i += int_index_start;

			




	
	
	
		
 
    if (xAsIndex)

			




	
	
	
		
 
    {

			




	
	
	
		
 
        return QPointF(i, _buffer->sample(i));

			




	
	
	
		
 
    }

			




	
	
	
		
 
    else

			




	
	
	
		
 
    {

			




	
	
	
		
 
        return QPointF(i * (_xmax - _xmin) / _buffer->size() + _xmin, _buffer->sample(i));

			




	
	
	
		
 
    }

			




	
	
	
		
 
    return QPointF(_x->sample(i), _y->sample(i));

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
QRectF FrameBufferSeries::boundingRect() const

			




	
	
	
		
 
{

			




	
	
	
		
 
    QRectF rect;

			




	
	
	
		
 
    auto yLim = _buffer->limits();

			




	
	
	
		
 
    auto yLim = _y->limits();

			




	
	
	
		
 
    auto xLim = _x->limits();

			




	
	
	
		
 
    rect.setBottom(yLim.start);

			




	
	
	
		
 
    rect.setTop(yLim.end);

			




	
	
	
		
 
    if (xAsIndex)

			




	
	
	
		
 
    {

			




	
	
	
		
 
        rect.setLeft(0);

			




	
	
	
		
 
        rect.setRight(size());

			




	
	
	
		
 
    }

			




	
	
	
		
 
    else

			




	
	
	
		
 
    {

			




	
	
	
		
 
        rect.setLeft(_xmin);

			




	
	
	
		
 
        rect.setRight(_xmax);

			




	
	
	
		
 
    }

			




	
	
	
		
 
    rect.setLeft(xLim.start);

			




	
	
	
		
 
    rect.setRight(xLim.end);

			




	
	
	
		
 

			




	
	
	
		
 
    return rect.normalized();

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
void FrameBufferSeries::setRectOfInterest(const QRectF& rect)

			




	
	
	
		
 
{

			




	
	
	
		
 
    if (xAsIndex)

			




	
	
	
		
 
    int_index_start = _x->findIndex(rect.left());

			




	
	
	
		
 
    int_index_end = _x->findIndex(rect.right());

			




	
	
	
		
 

			




	
	
	
		
 
    if (int_index_start == XFrameBuffer::OUT_OF_RANGE)

			




	
	
	
		
 
    {

			




	
	
	
		
 
        int_index_start = floor(rect.left())-1;

			




	
	
	
		
 
        int_index_end = ceil(rect.right())+1;

			




	
	
	
		
 
        int_index_start = 0;

			




	
	
	
		
 
    }

			




	
	
	
		
 
    else

			




	
	
	
		
 
    else if (int_index_start > 0)

			




	
	
	
		
 
    {

			




	
	
	
		
 
        double xsize = _xmax - _xmin;

			




	
	
	
		
 
        size_t bsize = _buffer->size();

			




	
	
	
		
 
        int_index_start =  floor(bsize * (rect.left()-_xmin) / xsize)-1;

			




	
	
	
		
 
        int_index_end = ceil(bsize * (rect.right()-_xmin) / xsize)+1;

			




	
	
	
		
 
        int_index_start -= 1;

			




	
	
	
		
 
    }

			




	
	
	
		
 

			




	
	
	
		
 
    int_index_start = std::max(int_index_start, 0);

			




	
	
	
		
 
    int_index_end = std::min((int) _buffer->size(), int_index_end);

			




	
	
	
		
 
    if (int_index_end == XFrameBuffer::OUT_OF_RANGE)

			




	
	
	
		
 
    {

			




	
	
	
		
 
        int_index_end = _x->size()-1;

			




	
	
	
		
 
    }

			




	
	
	
		
 
    else if (int_index_end < (int)_x->size()-1)

			




	
	
	
		
 
    {

			




	
	
	
		
 
        int_index_end += 1;

			




	
	
	
		
 
    }

			




	
	
	
		
 
}

			




        

    


    
    

    

        

                

                    src/framebufferseries.h
                

                

                  
                      
                        

                      ➞

                      
                        
                  

                  
                      
                  
                      
                  
                      
                  
                      
                  
                  
                

                

                    Show inline comments
                    
                

        

        

            



	
	
	
		
 
/*

			




	
	
	
		
 
  Copyright © 2018 Hasan Yavuz Özderya

			




	
	
	
		
 

			




	
	
	
		
 
  This file is part of serialplot.

			




	
	
	
		
 

			




	
	
	
		
 
  serialplot is free software: you can redistribute it and/or modify

			




	
	
	
		
 
  it under the terms of the GNU General Public License as published by

			




	
	
	
		
 
  the Free Software Foundation, either version 3 of the License, or

			




	
	
	
		
 
  (at your option) any later version.

			




	
	
	
		
 

			




	
	
	
		
 
  serialplot is distributed in the hope that it will be useful,

			




	
	
	
		
 
  but WITHOUT ANY WARRANTY; without even the implied warranty of

			




	
	
	
		
 
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

			




	
	
	
		
 
  GNU General Public License for more details.

			




	
	
	
		
 

			




	
	
	
		
 
  You should have received a copy of the GNU General Public License

			




	
	
	
		
 
  along with serialplot.  If not, see <http://www.gnu.org/licenses/>.

			




	
	
	
		
 
*/

			




	
	
	
		
 

			




	
	
	
		
 
#ifndef FRAMEBUFFERSERIES_H

			




	
	
	
		
 
#define FRAMEBUFFERSERIES_H

			




	
	
	
		
 

			




	
	
	
		
 
#include <QPointF>

			




	
	
	
		
 
#include <QRectF>

			




	
	
	
		
 
#include <qwt_series_data.h>

			




	
	
	
		
 

			




	
	
	
		
 
#include "framebuffer.h"

			




	
	
	
		
 

			




	
	
	
		
 
/**

			




	
	
	
		
 
 * This class provides an interface for actual FrameBuffer

			




	
	
	
		
 
 * object. That way we can keep our data structures relatively

			




	
	
	
		
 
 * isolated from Qwt. Otherwise QwtPlotCurve owns FrameBuffer

			




	
	
	
		
 
 * structures.

			




	
	
	
		
 
 */

			




	
	
	
		
 
class FrameBufferSeries : public QwtSeriesData<QPointF>

			




	
	
	
		
 
{

			




	
	
	
		
 
public:

			




	
	
	
		
 
    FrameBufferSeries(const FrameBuffer* buffer);

			




	
	
	
		
 
    FrameBufferSeries(const XFrameBuffer* x, const FrameBuffer* y);

			




	
	
	
		
 

			




	
	
	
		
 
    /// Behavior of X axis

			




	
	
	
		
 
    void setXAxis(bool asIndex, double xmin, double xmax);

			




	
	
	
		
 
    void setX(const XFrameBuffer* x);

			




	
	
	
		
 

			




	
	
	
		
 
    // QwtSeriesData implementations

			




	
	
	
		
 
    size_t size() const;

			




	
	
	
		
 
    QPointF sample(size_t i) const;

			




	
	
	
		
 
    QRectF boundingRect() const;

			




	
	
	
		
 
    void setRectOfInterest(const QRectF& rect);

			




	
	
	
		
 

			




	
	
	
		
 
private:

			




	
	
	
		
 
    const FrameBuffer* _buffer;

			




	
	
	
		
 
    bool xAsIndex;

			




	
	
	
		
 
    double _xmin;

			




	
	
	
		
 
    double _xmax;

			




	
	
	
		
 
    const XFrameBuffer* _x;

			




	
	
	
		
 
    const FrameBuffer* _y;

			




	
	
	
		
 

			




	
	
	
		
 
    int int_index_start; ///< starting index of "rectangle of interest"

			




	
	
	
		
 
    int int_index_end;   ///< ending index of "rectangle of interest"

			




	
	
	
		
 
};

			




	
	
	
		
 

			




	
	
	
		
 
#endif // FRAMEBUFFERSERIES_H

			




        

    


    
    

    

        

                

                    src/linindexbuffer.cpp
                

                

                  
                      
                        

                      ➞

                      
                        
                  

                  
                      
                  
                      
                  
                      
                  
                      
                  
                  
                

                

                    Show inline comments
                    
                

        

        

            



	
	
	
		
 
 /*

			




	
	
	
		
 
  Copyright © 2017 Hasan Yavuz Özderya

			




	
	
	
		
 
  Copyright © 2018 Hasan Yavuz Özderya

			




	
	
	
		
 

			




	
	
	
		
 
  This file is part of serialplot.

			




	
	
	
		
 

			




	
	
	
		
 
  serialplot is free software: you can redistribute it and/or modify

			




	
	
	
		
 
  it under the terms of the GNU General Public License as published by

			




	
	
	
		
 
  the Free Software Foundation, either version 3 of the License, or

			




	
	
	
		
 
  (at your option) any later version.

			




	
	
	
		
 

			




	
	
	
		
 
  serialplot is distributed in the hope that it will be useful,

			




	
	
	
		
 
  but WITHOUT ANY WARRANTY; without even the implied warranty of

			




	
	
	
		
 
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

			




	
	
	
		
 
  GNU General Public License for more details.

			




	
	
	
		
 

			




	
	
	
		
 
  You should have received a copy of the GNU General Public License

			




	
	
	
		
 
  along with serialplot.  If not, see <http://www.gnu.org/licenses/>.

			




	
	
	
		
 
*/

			




	
	
	
		
 

			




	
	
	
		
 
#include <QtGlobal>

			




	
	
	
		
 
#include <algorithm>

			




	
	
	
		
 

			




	
	
	
		
 
#include "linindexbuffer.h"

			




	
	
	
		
 

			




	
	
	
		
 
LinIndexBuffer::LinIndexBuffer(unsigned n, Range lim)

			




	
	
	
		
 
{

			




	
	
	
		
 
    Q_ASSERT(n > 0);

			




	
	
	
		
 
    // Note that calculation of _step would cause divide by 0

			




	
	
	
		
 
    Q_ASSERT(n > 1);

			




	
	
	
		
 

			




	
	
	
		
 
    _size = n;

			




	
	
	
		
 
    setLimits(lim);

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
unsigned LinIndexBuffer::size() const

			




	
	
	
		
 
{

			




	
	
	
		
 
    return _size;

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
double LinIndexBuffer::sample(unsigned i) const

			




	
	
	
		
 
{

			




	
	
	
		
 
    return _limits.start + i * _step;

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
Range LinIndexBuffer::limits() const

			




	
	
	
		
 
{

			




	
	
	
		
 
    return _limits;

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
void LinIndexBuffer::resize(unsigned n)

			




	
	
	
		
 
{

			




	
	
	
		
 
    _size = n;

			




	
	
	
		
 
    setLimits(_limits);         // called to update `_step`

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
int LinIndexBuffer::findIndex(double value) const

			




	
	
	
		
 
{

			




	
	
	
		
 
    if (value < _limits.start || value > _limits.end)

			




	
	
	
		
 
    {

			




	
	
	
		
 
        return OUT_OF_RANGE;

			




	
	
	
		
 
    }

			




	
	
	
		
 

			




	
	
	
		
 
    int r = (value - _limits.start) / _step;

			




	
	
	
		
 
    // Note: we are limiting return value because of floating point in-accuracies

			




	
	
	
		
 
    return std::min<int>(std::max<int>(r, 0), (_size-1));

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
void LinIndexBuffer::setLimits(Range lim)

			




	
	
	
		
 
{

			




	
	
	
		
 
    _limits = lim;

			




	
	
	
		
 
    _step = (lim.end - lim.start) / (_size-1);

			




	
	
	
		
 
}

			




        

    


    
    

    

        

                

                    src/linindexbuffer.h
                

                

                  
                      
                        

                      ➞

                      
                        
                  

                  
                      
                  
                      
                  
                      
                  
                      
                  
                  
                

                

                    Show inline comments
                    
                

        

        

            



	
	
	
		
 
 /*

			




	
	
	
		
 
  Copyright © 2018 Hasan Yavuz Özderya

			




	
	
	
		
 

			




	
	
	
		
 
  This file is part of serialplot.

			




	
	
	
		
 

			




	
	
	
		
 
  serialplot is free software: you can redistribute it and/or modify

			




	
	
	
		
 
  it under the terms of the GNU General Public License as published by

			




	
	
	
		
 
  the Free Software Foundation, either version 3 of the License, or

			




	
	
	
		
 
  (at your option) any later version.

			




	
	
	
		
 

			




	
	
	
		
 
  serialplot is distributed in the hope that it will be useful,

			




	
	
	
		
 
  but WITHOUT ANY WARRANTY; without even the implied warranty of

			




	
	
	
		
 
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

			




	
	
	
		
 
  GNU General Public License for more details.

			




	
	
	
		
 

			




	
	
	
		
 
  You should have received a copy of the GNU General Public License

			




	
	
	
		
 
  along with serialplot.  If not, see <http://www.gnu.org/licenses/>.

			




	
	
	
		
 
*/

			




	
	
	
		
 

			




	
	
	
		
 
#ifndef LININDEXBUFFER_H

			




	
	
	
		
 
#define LININDEXBUFFER_H

			




	
	
	
		
 

			




	
	
	
		
 
#include "framebuffer.h"

			




	
	
	
		
 

			




	
	
	
		
 
/// A dynamic frame buffer that start and end values can be set and

			




	
	
	
		
 
/// intermediate values are calculated linearly.

			




	
	
	
		
 
///

			




	
	
	
		
 
/// @note This buffer isn't for storing data.

			




	
	
	
		
 
class LinIndexBuffer : public ResizableBuffer

			




	
	
	
		
 
class LinIndexBuffer : public XFrameBuffer

			




	
	
	
		
 
{

			




	
	
	
		
 
public:

			




	
	
	
		
 
    LinIndexBuffer(unsigned n, Range lim);

			




	
	
	
		
 
    LinIndexBuffer(unsigned n, double min, double max) :

			




	
	
	
		
 
        LinIndexBuffer(n, {min, max}) {};

			




	
	
	
		
 

			




	
	
	
		
 
    unsigned size() const;

			




	
	
	
		
 
    double sample(unsigned i) const;

			




	
	
	
		
 
    Range limits() const;

			




	
	
	
		
 
    void resize(unsigned n);

			




	
	
	
		
 
    unsigned size() const override;

			




	
	
	
		
 
    double sample(unsigned i) const override;

			




	
	
	
		
 
    Range limits() const override;

			




	
	
	
		
 
    void resize(unsigned n) override;

			




	
	
	
		
 
    int findIndex(double value) const override;

			




	
	
	
		
 

			




	
	
	
		
 
    /// Sets minimum and maximum sample values of the buffer.

			




	
	
	
		
 
    void setLimits(Range lim);

			




	
	
	
		
 

			




	
	
	
		
 
private:

			




	
	
	
		
 
    unsigned _size;

			




	
	
	
		
 
    Range _limits;

			




	
	
	
		
 
    double _step;

			




	
	
	
		
 
};

			




	
	
	
		
 

			




	
	
	
		
 
#endif

			




        

    


    
    

    

        

                

                    src/mainwindow.cpp
                

                

                  
                      
                        

                      ➞

                      
                        
                  

                  
                      
                  
                      
                  
                      
                  
                      
                  
                  
                

                

                    Show inline comments
                    
                

        

        

            



	
	
	
		
 
/*

			




	
	
	
		
 
  Copyright © 2018 Hasan Yavuz Özderya

			




	
	
	
		
 

			




	
	
	
		
 
  This file is part of serialplot.

			




	
	
	
		
 

			




	
	
	
		
 
  serialplot is free software: you can redistribute it and/or modify

			




	
	
	
		
 
  it under the terms of the GNU General Public License as published by

			




	
	
	
		
 
  the Free Software Foundation, either version 3 of the License, or

			




	
	
	
		
 
  (at your option) any later version.

			




	
	
	
		
 

			




	
	
	
		
 
  serialplot is distributed in the hope that it will be useful,

			




	
	
	
		
 
  but WITHOUT ANY WARRANTY; without even the implied warranty of

			




	
	
	
		
 
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

			




	
	
	
		
 
  GNU General Public License for more details.

			




	
	
	
		
 

			




	
	
	
		
 
  You should have received a copy of the GNU General Public License

			




	
	
	
		
 
  along with serialplot.  If not, see <http://www.gnu.org/licenses/>.

			




	
	
	
		
 
*/

			




	
	
	
		
 

			




	
	
	
		
 
#include "mainwindow.h"

			




	
	
	
		
 
#include "ui_mainwindow.h"

			




	
	
	
		
 
#include <QByteArray>

			




	
	
	
		
 
#include <QApplication>

			




	
	
	
		
 
#include <QFileDialog>

			




	
	
	
		
 
#include <QMessageBox>

			




	
	
	
		
 
#include <QFile>

			




	
	
	
		
 
#include <QTextStream>

			




	
	
	
		
 
#include <QMenu>

			




	
	
	
		
 
#include <QDesktopServices>

			




	
	
	
		
 
#include <QMap>

			




	
	
	
		
 
#include <QtDebug>

			




	
	
	
		
 
#include <qwt_plot.h>

			




	
	
	
		
 
#include <limits.h>

			




	
	
	
		
 
#include <cmath>

			




	
	
	
		
 
#include <iostream>

			




	
	
	
		
 

			




	
	
	
		
 
#include <plot.h>

			




	
	
	
		
 
#include <barplot.h>

			




	
	
	
		
 

			




	
	
	
		
 
#include "framebufferseries.h"

			




	
	
	
		
 
#include "utils.h"

			




	
	
	
		
 
#include "defines.h"

			




	
	
	
		
 
#include "version.h"

			




	
	
	
		
 
#include "setting_defines.h"

			




	
	
	
		
 

			




	
	
	
		
 
#if defined(Q_OS_WIN) && defined(QT_STATIC)

			




	
	
	
		
 
#include <QtPlugin>

			




	
	
	
		
 
Q_IMPORT_PLUGIN(QWindowsIntegrationPlugin)

			




	
	
	
		
 
#endif

			




	
	
	
		
 

			




	
	
	
		
 
// TODO: depends on tab insertion order, a better solution would be to use object names

			




	
	
	
		
 
const QMap<int, QString> panelSettingMap({

			




	
	
	
		
 
        {0, "Port"},

			




	
	
	
		
 
        {1, "DataFormat"},

			




	
	
	
		
 
        {2, "Plot"},

			




	
	
	
		
 
        {3, "Commands"},

			




	
	
	
		
 
        {4, "Record"},

			




	
	
	
		
 
        {5, "Log"}

			




	
	
	
		
 
    });

			




	
	
	
		
 

			




	
	
	
		
 
MainWindow::MainWindow(QWidget *parent) :

			




	
	
	
		
 
    QMainWindow(parent),

			




	
	
	
		
 
    ui(new Ui::MainWindow),

			




	
	
	
		
 
    aboutDialog(this),

			




	
	
	
		
 
    portControl(&serialPort),

			




	
	
	
		
 
    secondaryPlot(NULL),

			




	
	
	
		
 
    snapshotMan(this, &stream),

			




	
	
	
		
 
    commandPanel(&serialPort),

			




	
	
	
		
 
    dataFormatPanel(&serialPort),

			




	
	
	
		
 
    recordPanel(&stream),

			




	
	
	
		
 
    updateCheckDialog(this)

			




	
	
	
		
 
{

			




	
	
	
		
 
    ui->setupUi(this);

			




	
	
	
		
 

			




	
	
	
		
 
    plotMan = new PlotManager(ui->plotArea, &plotMenu, &stream);

			




	
	
	
		
 

			




	
	
	
		
 
    ui->tabWidget->insertTab(0, &portControl, "Port");

			




	
	
	
		
 
    ui->tabWidget->insertTab(1, &dataFormatPanel, "Data Format");

			




	
	
	
		
 
    ui->tabWidget->insertTab(2, &plotControlPanel, "Plot");

			




	
	
	
		
 
    ui->tabWidget->insertTab(3, &commandPanel, "Commands");

			




	
	
	
		
 
    ui->tabWidget->insertTab(4, &recordPanel, "Record");

			




	
	
	
		
 
    ui->tabWidget->setCurrentIndex(0);

			




	
	
	
		
 
    auto tbPortControl = portControl.toolBar();

			




	
	
	
		
 
    addToolBar(tbPortControl);

			




	
	
	
		
 
    addToolBar(recordPanel.toolbar());

			




	
	
	
		
 

			




	
	
	
		
 
    ui->plotToolBar->addAction(snapshotMan.takeSnapshotAction());

			




	
	
	
		
 
    menuBar()->insertMenu(ui->menuHelp->menuAction(), snapshotMan.menu());

			




	
	
	
		
 
    menuBar()->insertMenu(ui->menuHelp->menuAction(), commandPanel.menu());

			




	
	
	
		
 

			




	
	
	
		
 
    connect(&commandPanel, &CommandPanel::focusRequested, [this]()

			




	
	
	
		
 
            {

			




	
	
	
		
 
                this->ui->tabWidget->setCurrentWidget(&commandPanel);

			




	
	
	
		
 
                this->ui->tabWidget->showTabs();

			




	
	
	
		
 
            });

			




	
	
	
		
 

			




	
	
	
		
 
    tbPortControl->setObjectName("tbPortControl");

			




	
	
	
		
 
    ui->plotToolBar->setObjectName("tbPlot");

			




	
	
	
		
 

			




	
	
	
		
 
    setupAboutDialog();

			




	
	
	
		
 

			




	
	
	
		
 
    // init view menu

			




	
	
	
		
 
    ui->menuBar->insertMenu(ui->menuSecondary->menuAction(), &plotMenu);

			




	
	
	
		
 
    plotMenu.addSeparator();

			




	
	
	
		
 
    QMenu* tbMenu = plotMenu.addMenu("Toolbars");

			




	
	
	
		
 
    tbMenu->addAction(ui->plotToolBar->toggleViewAction());

			




	
	
	
		
 
    tbMenu->addAction(portControl.toolBar()->toggleViewAction());

			




	
	
	
		
 

			




	
	
	
		
 
    // init secondary plot menu

			




	
	
	
		
 
    auto group = new QActionGroup(this);

			




	
	
	
		
 
    group->addAction(ui->actionVertical);

			




	
	
	
		
 
    group->addAction(ui->actionHorizontal);

			




	
	
	
		
 

			




	
	
	
		
 
    // init UI signals

			




	
	
	
		
 

			




	
	
	
		
 
    // Secondary plot menu signals

			




	
	
	
		
 
    connect(ui->actionBarPlot, &QAction::triggered,

			




	
	
	
		
 
            this, &MainWindow::showBarPlot);

			




	
	
	
		
 

			




	
	
	
		
 
    connect(ui->actionVertical, &QAction::triggered,

			




	
	
	
		
 
            [this](bool checked)

			




	
	
	
		
 
            {

			




	
	
	
		
 
                if (checked) ui->splitter->setOrientation(Qt::Vertical);

			




	
	
	
		
 
            });

			




	
	
	
		
 

			




	
	
	
		
 
    connect(ui->actionHorizontal, &QAction::triggered,

			




	
	
	
		
 
            [this](bool checked)

			




	
	
	
		
 
            {

			




	
	
	
		
 
                if (checked) ui->splitter->setOrientation(Qt::Horizontal);

			




	
	
	
		
 
            });

			




	
	
	
		
 

			




	
	
	
		
 
    // Help menu signals

			




	
	
	
		
 
    QObject::connect(ui->actionHelpAbout, &QAction::triggered,

			




	
	
	
		
 
              &aboutDialog, &QWidget::show);

			




	
	
	
		
 

			




	
	
	
		
 
    QObject::connect(ui->actionCheckUpdate, &QAction::triggered,

			




	
	
	
		
 
              &updateCheckDialog, &QWidget::show);

			




	
	
	
		
 

			




	
	
	
		
 
    QObject::connect(ui->actionReportBug, &QAction::triggered,

			




	
	
	
		
 
                     [](){QDesktopServices::openUrl(QUrl(BUG_REPORT_URL));});

			




	
	
	
		
 

			




	
	
	
		
 
    // File menu signals

			




	
	
	
		
 
    QObject::connect(ui->actionExportCsv, &QAction::triggered,

			




	
	
	
		
 
                     this, &MainWindow::onExportCsv);

			




	
	
	
		
 

			




	
	
	
		
 
    QObject::connect(ui->actionSaveSettings, &QAction::triggered,

			




	
	
	
		
 
                     this, &MainWindow::onSaveSettings);

			




	
	
	
		
 

			




	
	
	
		
 
    QObject::connect(ui->actionLoadSettings, &QAction::triggered,

			




	
	
	
		
 
                     this, &MainWindow::onLoadSettings);

			




	
	
	
		
 

			




	
	
	
		
 
    ui->actionQuit->setShortcutContext(Qt::ApplicationShortcut);

			




	
	
	
		
 

			




	
	
	
		
 
    QObject::connect(ui->actionQuit, &QAction::triggered,

			




	
	
	
		
 
                     this, &MainWindow::close);

			




	
	
	
		
 

			




	
	
	
		
 
    // port control signals

			




	
	
	
		
 
    QObject::connect(&portControl, &PortControl::portToggled,

			




	
	
	
		
 
                     this, &MainWindow::onPortToggled);

			




	
	
	
		
 

			




	
	
	
		
 
    // plot control signals

			




	
	
	
		
 
    connect(&plotControlPanel, &PlotControlPanel::numOfSamplesChanged,

			




	
	
	
		
 
            this, &MainWindow::onNumOfSamplesChanged);

			




	
	
	
		
 

			




	
	
	
		
 
    connect(&plotControlPanel, &PlotControlPanel::numOfSamplesChanged,

			




	
	
	
		
 
            plotMan, &PlotManager::setNumOfSamples);

			




	
	
	
		
 

			




	
	
	
		
 
    connect(&plotControlPanel, &PlotControlPanel::yScaleChanged,

			




	
	
	
		
 
            plotMan, &PlotManager::setYAxis);

			




	
	
	
		
 

			




	
	
	
		
 
    connect(&plotControlPanel, &PlotControlPanel::xScaleChanged,

			




	
	
	
		
 
            &stream, &Stream::setXAxis);

			




	
	
	
		
 

			




	
	
	
		
 
    connect(&plotControlPanel, &PlotControlPanel::xScaleChanged,

			




	
	
	
		
 
            plotMan, &PlotManager::setXAxis);

			




	
	
	
		
 

			




	
	
	
		
 
    connect(&plotControlPanel, &PlotControlPanel::plotWidthChanged,

			




	
	
	
		
 
            plotMan, &PlotManager::setPlotWidth);

			




	
	
	
		
 

			




	
	
	
		
 
    // plot toolbar signals

			




	
	
	
		
 
    QObject::connect(ui->actionClear, SIGNAL(triggered(bool)),

			




	
	
	
		
 
                     this, SLOT(clearPlot()));

			




	
	
	
		
 

			




	
	
	
		
 
    QObject::connect(snapshotMan.takeSnapshotAction(), &QAction::triggered,

			




	
	
	
		
 
                     plotMan, &PlotManager::flashSnapshotOverlay);

			




	
	
	
		
 

			




	
	
	
		
 
    QObject::connect(ui->actionPause, &QAction::triggered,

			




	
	
	
		
 
                     &stream, &Stream::pause);

			




	
	
	
		
 

			




	
	
	
		
 
    QObject::connect(ui->actionPause, &QAction::triggered,

			




	
	
	
		
 
                     [this](bool enabled)

			




	
	
	
		
 
                     {

			




	
	
	
		
 
                         if (enabled && !recordPanel.recordPaused())

			




	
	
	
		
 
                         {

			




	
	
	
		
 
                             dataFormatPanel.pause(true);

			




	
	
	
		
 
                         }

			




	
	
	
		
 
                         else

			




	
	
	
		
 
                         {

			




	
	
	
		
 
                             dataFormatPanel.pause(false);

			




	
	
	
		
 
                         }

			




	
	
	
		
 
                     });

			




	
	
	
		
 

			




	
	
	
		
 
    QObject::connect(&recordPanel, &RecordPanel::recordPausedChanged,

			




	
	
	
		
 
                     [this](bool enabled)

			




	
	
	
		
 
                     {

			




	
	
	
		
 
                         if (ui->actionPause->isChecked() && enabled)

			




	
	
	
		
 
                         {

			




	
	
	
		
 
                             dataFormatPanel.pause(false);

			




	
	
	
		
 
                         }

			




	
	
	
		
 
                     });

			




	
	
	
		
 

			




	
	
	
		
 
    connect(&serialPort, &QIODevice::aboutToClose,

			




	
	
	
		
 
            &recordPanel, &RecordPanel::onPortClose);

			




	
	
	
		
 

			




	
	
	
		
 
    // init plot

			




	
	
	
		
 
    numOfSamples = plotControlPanel.numOfSamples();

			




	
	
	
		
 
    stream.setNumSamples(numOfSamples);

			




	
	
	
		
 
    plotControlPanel.setChannelInfoModel(stream.infoModel());

			




	
	
	
		
 

			




	
	
	
		
 
    // init scales

			




	
	
	
		
 
    stream.setXAxis(plotControlPanel.xAxisAsIndex(),

			




	
	
	
		
 
                    plotControlPanel.xMin(), plotControlPanel.xMax());

			




	
	
	
		
 

			




	
	
	
		
 
    plotMan->setYAxis(plotControlPanel.autoScale(),

			




	
	
	
		
 
                      plotControlPanel.yMin(), plotControlPanel.yMax());

			




	
	
	
		
 
    plotMan->setXAxis(plotControlPanel.xAxisAsIndex(),

			




	
	
	
		
 
                      plotControlPanel.xMin(), plotControlPanel.xMax());

			




	
	
	
		
 
    plotMan->setNumOfSamples(numOfSamples);

			




	
	
	
		
 
    plotMan->setPlotWidth(plotControlPanel.plotWidth());

			




	
	
	
		
 

			




	
	
	
		
 
    // Init sps (sample per second) counter

			




	
	
	
		
 
    spsLabel.setText("0sps");

			




	
	
	
		
 
    spsLabel.setToolTip("samples per second (per channel)");

			




	
	
	
		
 
    ui->statusBar->addPermanentWidget(&spsLabel);

			




	
	
	
		
 
    connect(&sampleCounter, &SampleCounter::spsChanged,

			




	
	
	
		
 
            this, &MainWindow::onSpsChanged);

			




	
	
	
		
 

			




	
	
	
		
 
    // init demo

			




	
	
	
		
 
    QObject::connect(ui->actionDemoMode, &QAction::toggled,

			




	
	
	
		
 
                     this, &MainWindow::enableDemo);

			




	
	
	
		
 

			




	
	
	
		
 
    QObject::connect(ui->actionDemoMode, &QAction::toggled,

			




	
	
	
		
 
                     plotMan, &PlotManager::showDemoIndicator);

			




	
	
	
		
 

			




	
	
	
		
 
    // init stream connections

			




	
	
	
		
 
    connect(&dataFormatPanel, &DataFormatPanel::sourceChanged,

			




	
	
	
		
 
            this, &MainWindow::onSourceChanged);

			




	
	
	
		
 
    onSourceChanged(dataFormatPanel.activeSource());

			




	
	
	
		
 

			




	
	
	
		
 
    // load default settings

			




	
	
	
		
 
    QSettings settings("serialplot", "serialplot");

			




	
	
	
		
 
    loadAllSettings(&settings);

			




	
	
	
		
 

			




	
	
	
		
 
    // ensure command panel has 1 command if none loaded

			




	
	
	
		
 
    if (!commandPanel.numOfCommands())

			




	
	
	
		
 
    {

			




	
	
	
		
 
        commandPanel.newCommandAction()->trigger();

			




	
	
	
		
 
    }

			




	
	
	
		
 

			




	
	
	
		
 
    // Important: This should be after newCommandAction is triggered

			




	
	
	
		
 
    // (above) we don't want user to be greeted with command panel on

			




	
	
	
		
 
    // the very first run.

			




	
	
	
		
 
    connect(commandPanel.newCommandAction(), &QAction::triggered, [this]()

			




	
	
	
		
 
            {

			




	
	
	
		
 
                this->ui->tabWidget->setCurrentWidget(&commandPanel);

			




	
	
	
		
 
                this->ui->tabWidget->showTabs();

			




	
	
	
		
 
            });

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
MainWindow::~MainWindow()

			




	
	
	
		
 
{

			




	
	
	
		
 
    if (serialPort.isOpen())

			




	
	
	
		
 
    {

			




	
	
	
		
 
        serialPort.close();

			




	
	
	
		
 
    }

			




	
	
	
		
 

			




	
	
	
		
 
    delete plotMan;

			




	
	
	
		
 

			




	
	
	
		
 
    delete ui;

			




	
	
	
		
 
    ui = NULL; // we check if ui is deleted in messageHandler

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
void MainWindow::closeEvent(QCloseEvent * event)

			




	
	
	
		
 
{

			




	
	
	
		
 
    // save snapshots

			




	
	
	
		
 
    if (!snapshotMan.isAllSaved())

			




	
	
	
		
 
    {

			




	
	
	
		
 
        auto clickedButton = QMessageBox::warning(

			




	
	
	
		
 
            this, "Closing SerialPlot",

			




	
	
	
		
 
            "There are un-saved snapshots. If you close you will loose the data.",

			




	
	
	
		
 
            QMessageBox::Discard, QMessageBox::Cancel);

			




	
	
	
		
 
        if (clickedButton == QMessageBox::Cancel)

			




	
	
	
		
 
        {

			




	
	
	
		
 
            event->ignore();

			




	
	
	
		
 
            return;

			




	
	
	
		
 
        }

			




	
	
	
		
 
    }

			




	
	
	
		
 

			




	
	
	
		
 
    // save settings

			




	
	
	
		
 
    QSettings settings("serialplot", "serialplot");

			




	
	
	
		
 
    saveAllSettings(&settings);

			




	
	
	
		
 
    settings.sync();

			




	
	
	
		
 

			




	
	
	
		
 
    if (settings.status() != QSettings::NoError)

			




	
	
	
		
 
    {

			




	
	
	
		
 
        QString errorText;

			




	
	
	
		
 

			




	
	
	
		
 
        if (settings.status() == QSettings::AccessError)

			




	
	
	
		
 
        {

			




	
	
	
		
 
            QString file = settings.fileName();

			




	
	
	
		
 
            errorText = QString("Serialplot cannot save settings due to access error. \

			




	
	
	
		
 
This happens if you have run serialplot as root (with sudo for ex.) previously. \

			




	
	
	
		
 
Try fixing the permissions of file: %1, or just delete it.").arg(file);

			




	
	
	
		
 
        }

			




	
	
	
		
 
        else

			




	
	
	
		
 
        {

			




	
	
	
		
 
            errorText = QString("Serialplot cannot save settings due to unknown error: %1").\

			




	
	
	
		
 
                arg(settings.status());

			




	
	
	
		
 
        }

			




	
	
	
		
 

			




	
	
	
		
 
        auto button = QMessageBox::critical(

			




	
	
	
		
 
            NULL,

			




	
	
	
		
 
            "Failed to save settings!", errorText,

			




	
	
	
		
 
            QMessageBox::Cancel | QMessageBox::Ok);

			




	
	
	
		
 

			




	
	
	
		
 
        if (button == QMessageBox::Cancel)

			




	
	
	
		
 
        {

			




	
	
	
		
 
            event->ignore();

			




	
	
	
		
 
            return;

			




	
	
	
		
 
        }

			




	
	
	
		
 
    }

			




	
	
	
		
 

			




	
	
	
		
 
    QMainWindow::closeEvent(event);

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
void MainWindow::setupAboutDialog()

			




	
	
	
		
 
{

			




	
	
	
		
 
    Ui_AboutDialog uiAboutDialog;

			




	
	
	
		
 
    uiAboutDialog.setupUi(&aboutDialog);

			




	
	
	
		
 

			




	
	
	
		
 
    QObject::connect(uiAboutDialog.pbAboutQt, &QPushButton::clicked,

			




	
	
	
		
 
                     [](){ QApplication::aboutQt();});

			




	
	
	
		
 

			




	
	
	
		
 
    QString aboutText = uiAboutDialog.lbAbout->text();

			




	
	
	
		
 
    aboutText.replace("$VERSION_STRING$", VERSION_STRING);

			




	
	
	
		
 
    aboutText.replace("$VERSION_REVISION$", VERSION_REVISION);

			




	
	
	
		
 
    uiAboutDialog.lbAbout->setText(aboutText);

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
void MainWindow::onPortToggled(bool open)

			




	
	
	
		
 
{

			




	
	
	
		
 
    // make sure demo mode is disabled

			




	
	
	
		
 
    if (open && isDemoRunning()) enableDemo(false);

			




	
	
	
		
 
    ui->actionDemoMode->setEnabled(!open);

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
void MainWindow::onSourceChanged(Source* source)

			




	
	
	
		
 
{

			




	
	
	
		
 
    source->connectSink(&stream);

			




	
	
	
		
 
    source->connectSink(&sampleCounter);

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
void MainWindow::clearPlot()

			




	
	
	
		
 
{

			




	
	
	
		
 
    stream.clear();

			




	
	
	
		
 
    plotMan->replot();

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
void MainWindow::onNumOfSamplesChanged(int value)

			




	
	
	
		
 
{

			




	
	
	
		
 
    numOfSamples = value;

			




	
	
	
		
 
    stream.setNumSamples(value);

			




	
	
	
		
 
    plotMan->replot();

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
void MainWindow::onSpsChanged(float sps)

			




	
	
	
		
 
{

			




	
	
	
		
 
    int precision = sps < 1. ? 3 : 0;

			




	
	
	
		
 
    spsLabel.setText(QString::number(sps, 'f', precision) + "sps");

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
bool MainWindow::isDemoRunning()

			




	
	
	
		
 
{

			




	
	
	
		
 
    return ui->actionDemoMode->isChecked();

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
void MainWindow::enableDemo(bool enabled)

			




	
	
	
		
 
{

			




	
	
	
		
 
    if (enabled)

			




	
	
	
		
 
    {

			




	
	
	
		
 
        if (!serialPort.isOpen())

			




	
	
	
		
 
        {

			




	
	
	
		
 
            dataFormatPanel.enableDemo(true);

			




	
	
	
		
 
        }

			




	
	
	
		
 
        else

			




	
	
	
		
 
        {

			




	
	
	
		
 
            ui->actionDemoMode->setChecked(false);

			




	
	
	
		
 
        }

			




	
	
	
		
 
    }

			




	
	
	
		
 
    else

			




	
	
	
		
 
    {

			




	
	
	
		
 
        dataFormatPanel.enableDemo(false);

			




	
	
	
		
 
        ui->actionDemoMode->setChecked(false);

			




	
	
	
		
 
    }

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
void MainWindow::showSecondary(QWidget* wid)

			




	
	
	
		
 
{

			




	
	
	
		
 
    if (secondaryPlot != NULL)

			




	
	
	
		
 
    {

			




	
	
	
		
 
        secondaryPlot->deleteLater();

			




	
	
	
		
 
    }

			




	
	
	
		
 

			




	
	
	
		
 
    secondaryPlot = wid;

			




	
	
	
		
 
    ui->splitter->addWidget(wid);

			




        

    


    
    

    

        

                

                    src/plotmanager.cpp
                

                

                  
                      
                        

                      ➞

                      
                        
                  

                  
                      
                  
                      
                  
                      
                  
                      
                  
                  
                

                

                    Show inline comments
                    
                

        

        

            



	
	
	
		
 
/*

			




	
	
	
		
 
  Copyright © 2018 Hasan Yavuz Özderya

			




	
	
	
		
 

			




	
	
	
		
 
  This file is part of serialplot.

			




	
	
	
		
 

			




	
	
	
		
 
  serialplot is free software: you can redistribute it and/or modify

			




	
	
	
		
 
  it under the terms of the GNU General Public License as published by

			




	
	
	
		
 
  the Free Software Foundation, either version 3 of the License, or

			




	
	
	
		
 
  (at your option) any later version.

			




	
	
	
		
 

			




	
	
	
		
 
  serialplot is distributed in the hope that it will be useful,

			




	
	
	
		
 
  but WITHOUT ANY WARRANTY; without even the implied warranty of

			




	
	
	
		
 
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

			




	
	
	
		
 
  GNU General Public License for more details.

			




	
	
	
		
 

			




	
	
	
		
 
  You should have received a copy of the GNU General Public License

			




	
	
	
		
 
  along with serialplot.  If not, see <http://www.gnu.org/licenses/>.

			




	
	
	
		
 
*/

			




	
	
	
		
 

			




	
	
	
		
 
#include <algorithm>

			




	
	
	
		
 
#include <QMetaEnum>

			




	
	
	
		
 
#include <QtDebug>

			




	
	
	
		
 
#include "qwt_symbol.h"

			




	
	
	
		
 

			




	
	
	
		
 
#include "plot.h"

			




	
	
	
		
 
#include "plotmanager.h"

			




	
	
	
		
 
#include "utils.h"

			




	
	
	
		
 
#include "setting_defines.h"

			




	
	
	
		
 

			




	
	
	
		
 
PlotManager::PlotManager(QWidget* plotArea, PlotMenu* menu,

			




	
	
	
		
 
                         const Stream* stream, QObject* parent) :

			




	
	
	
		
 
    QObject(parent)

			




	
	
	
		
 
{

			




	
	
	
		
 
    _stream = stream;

			




	
	
	
		
 
    construct(plotArea, menu);

			




	
	
	
		
 
    if (_stream == nullptr) return;

			




	
	
	
		
 

			




	
	
	
		
 
    // connect to ChannelInfoModel

			




	
	
	
		
 
    infoModel = _stream->infoModel();

			




	
	
	
		
 
    connect(infoModel, &QAbstractItemModel::dataChanged,

			




	
	
	
		
 
                this, &PlotManager::onChannelInfoChanged);

			




	
	
	
		
 
    connect(infoModel, &QAbstractItemModel::modelReset,

			




	
	
	
		
 
            [this]()

			




	
	
	
		
 
            {

			




	
	
	
		
 
                onChannelInfoChanged(infoModel->index(0, 0), // start

			




	
	
	
		
 
                                     infoModel->index(infoModel->rowCount()-1, 0), // end

			




	
	
	
		
 
                                     {}); // roles ignored

			




	
	
	
		
 
            });

			




	
	
	
		
 

			




	
	
	
		
 
    connect(stream, &Stream::numChannelsChanged, this, &PlotManager::onNumChannelsChanged);

			




	
	
	
		
 
    connect(stream, &Stream::dataAdded, this, &PlotManager::replot);

			




	
	
	
		
 

			




	
	
	
		
 
    // add initial curves if any?

			




	
	
	
		
 
    for (unsigned int i = 0; i < stream->numChannels(); i++)

			




	
	
	
		
 
    {

			




	
	
	
		
 
        addCurve(stream->channel(i)->name(), stream->channel(i)->yData());

			




	
	
	
		
 
        addCurve(stream->channel(i)->name(), stream->channel(i)->xData(), stream->channel(i)->yData());

			




	
	
	
		
 
    }

			




	
	
	
		
 

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
PlotManager::PlotManager(QWidget* plotArea, PlotMenu* menu,

			




	
	
	
		
 
                         Snapshot* snapshot, QObject *parent) :

			




	
	
	
		
 
    QObject(parent)

			




	
	
	
		
 
{

			




	
	
	
		
 
    _stream = nullptr;

			




	
	
	
		
 
    construct(plotArea, menu);

			




	
	
	
		
 

			




	
	
	
		
 
    setNumOfSamples(snapshot->numSamples());

			




	
	
	
		
 
    setPlotWidth(snapshot->numSamples());

			




	
	
	
		
 
    infoModel = snapshot->infoModel();

			




	
	
	
		
 

			




	
	
	
		
 
    for (unsigned ci = 0; ci < snapshot->numChannels(); ci++)

			




	
	
	
		
 
    {

			




	
	
	
		
 
        addCurve(snapshot->channelName(ci), snapshot->yData[ci]);

			




	
	
	
		
 
        addCurve(snapshot->channelName(ci), snapshot->xData[ci], snapshot->yData[ci]);

			




	
	
	
		
 
    }

			




	
	
	
		
 

			




	
	
	
		
 
    connect(infoModel, &QAbstractItemModel::dataChanged,

			




	
	
	
		
 
            this, &PlotManager::onChannelInfoChanged);

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
void PlotManager::construct(QWidget* plotArea, PlotMenu* menu)

			




	
	
	
		
 
{

			




	
	
	
		
 
    _menu = menu;

			




	
	
	
		
 
    _plotArea = plotArea;

			




	
	
	
		
 
    _autoScaled = true;

			




	
	
	
		
 
    _yMin = 0;

			




	
	
	
		
 
    _yMax = 1;

			




	
	
	
		
 
    _xAxisAsIndex = true;

			




	
	
	
		
 
    isDemoShown = false;

			




	
	
	
		
 
    _numOfSamples = 1;

			




	
	
	
		
 
    _plotWidth = 1;

			




	
	
	
		
 
    showSymbols = Plot::ShowSymbolsAuto;

			




	
	
	
		
 
    emptyPlot = NULL;

			




	
	
	
		
 

			




	
	
	
		
 
    // initalize layout and single widget

			




	
	
	
		
 
    isMulti = false;

			




	
	
	
		
 
    scrollArea = NULL;

			




	
	
	
		
 
    setupLayout(isMulti);

			




	
	
	
		
 
    addPlotWidget();

			




	
	
	
		
 

			




	
	
	
		
 
    // connect to  menu

			




	
	
	
		
 
    connect(menu, &PlotMenu::symbolShowChanged, this, &PlotManager:: setSymbols);

			




	
	
	
		
 

			




	
	
	
		
 
    connect(&menu->showGridAction, SELECT<bool>::OVERLOAD_OF(&QAction::toggled),

			




	
	
	
		
 
            this, &PlotManager::showGrid);

			




	
	
	
		
 
    connect(&menu->showMinorGridAction, SELECT<bool>::OVERLOAD_OF(&QAction::toggled),

			




	
	
	
		
 
            this, &PlotManager::showMinorGrid);

			




	
	
	
		
 
    connect(&menu->darkBackgroundAction, SELECT<bool>::OVERLOAD_OF(&QAction::toggled),

			




	
	
	
		
 
            this, &PlotManager::darkBackground);

			




	
	
	
		
 
    connect(&menu->showLegendAction, SELECT<bool>::OVERLOAD_OF(&QAction::toggled),

			




	
	
	
		
 
            this, &PlotManager::showLegend);

			




	
	
	
		
 
    connect(&menu->showMultiAction, SELECT<bool>::OVERLOAD_OF(&QAction::toggled),

			




	
	
	
		
 
            this, &PlotManager::setMulti);

			




	
	
	
		
 
    connect(&menu->unzoomAction, &QAction::triggered,

			




	
	
	
		
 
            this, &PlotManager::unzoom);

			




	
	
	
		
 

			




	
	
	
		
 
    // initial settings from menu actions

			




	
	
	
		
 
    showGrid(menu->showGridAction.isChecked());

			




	
	
	
		
 
    showMinorGrid(menu->showMinorGridAction.isChecked());

			




	
	
	
		
 
    darkBackground(menu->darkBackgroundAction.isChecked());

			




	
	
	
		
 
    showLegend(menu->showLegendAction.isChecked());

			




	
	
	
		
 
    setMulti(menu->showMultiAction.isChecked());

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
PlotManager::~PlotManager()

			




	
	
	
		
 
{

			




	
	
	
		
 
    while (curves.size())

			




	
	
	
		
 
    {

			




	
	
	
		
 
        delete curves.takeLast();

			




	
	
	
		
 
    }

			




	
	
	
		
 

			




	
	
	
		
 
    // remove all widgets

			




	
	
	
		
 
    while (plotWidgets.size())

			




	
	
	
		
 
    {

			




	
	
	
		
 
        delete plotWidgets.takeLast();

			




	
	
	
		
 
    }

			




	
	
	
		
 

			




	
	
	
		
 
    if (scrollArea != NULL) delete scrollArea;

			




	
	
	
		
 
    if (emptyPlot != NULL) delete emptyPlot;

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
void PlotManager::onNumChannelsChanged(unsigned value)

			




	
	
	
		
 
{

			




	
	
	
		
 
    unsigned int oldNum = numOfCurves();

			




	
	
	
		
 
    unsigned numOfChannels = value;

			




	
	
	
		
 

			




	
	
	
		
 
    if (numOfChannels > oldNum)

			




	
	
	
		
 
    {

			




	
	
	
		
 
        // add new channels

			




	
	
	
		
 
        for (unsigned int i = oldNum; i < numOfChannels; i++)

			




	
	
	
		
 
        {

			




	
	
	
		
 
            addCurve(_stream->channel(i)->name(), _stream->channel(i)->yData());

			




	
	
	
		
 
            addCurve(_stream->channel(i)->name(), _stream->channel(i)->xData(), _stream->channel(i)->yData());

			




	
	
	
		
 
        }

			




	
	
	
		
 
    }

			




	
	
	
		
 
    else if(numOfChannels < oldNum)

			




	
	
	
		
 
    {

			




	
	
	
		
 
        removeCurves(oldNum - numOfChannels);

			




	
	
	
		
 
    }

			




	
	
	
		
 

			




	
	
	
		
 
    replot();

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
void PlotManager::onChannelInfoChanged(const QModelIndex &topLeft,

			




	
	
	
		
 
                                       const QModelIndex &bottomRight,

			




	
	
	
		
 
                                       const QVector<int> &roles)

			




	
	
	
		
 
{

			




	
	
	
		
 
    int start = topLeft.row();

			




	
	
	
		
 
    int end = bottomRight.row();

			




	
	
	
		
 

			




	
	
	
		
 
    for (int ci = start; ci <= end; ci++)

			




	
	
	
		
 
    {

			




	
	
	
		
 
        QString name = topLeft.sibling(ci, ChannelInfoModel::COLUMN_NAME).data(Qt::EditRole).toString();

			




	
	
	
		
 
        QColor color = topLeft.sibling(ci, ChannelInfoModel::COLUMN_NAME).data(Qt::ForegroundRole).value<QColor>();

			




	
	
	
		
 
        bool visible = topLeft.sibling(ci, ChannelInfoModel::COLUMN_VISIBILITY).data(Qt::CheckStateRole).toBool();

			




	
	
	
		
 

			




	
	
	
		
 
        curves[ci]->setTitle(name);

			




	
	
	
		
 
        curves[ci]->setPen(color);

			




	
	
	
		
 
        curves[ci]->setVisible(visible);

			




	
	
	
		
 
        curves[ci]->setItemAttribute(QwtPlotItem::Legend, visible);

			




	
	
	
		
 

			




	
	
	
		
 
        // replot only updated widgets

			




	
	
	
		
 
        if (isMulti)

			




	
	
	
		
 
        {

			




	
	
	
		
 
            plotWidgets[ci]->updateSymbols(); // required for color change

			




	
	
	
		
 
            plotWidgets[ci]->updateLegend(curves[ci]);

			




	
	
	
		
 
            plotWidgets[ci]->setVisible(visible);

			




	
	
	
		
 
            if (visible)

			




	
	
	
		
 
            {

			




	
	
	
		
 
                plotWidgets[ci]->replot();

			




	
	
	
		
 
            }

			




	
	
	
		
 
        }

			




	
	
	
		
 
    }

			




	
	
	
		
 

			




	
	
	
		
 
    checkNoVisChannels();

			




	
	
	
		
 

			




	
	
	
		
 
    // replot single widget

			




	
	
	
		
 
    if (!isMulti)

			




	
	
	
		
 
    {

			




	
	
	
		
 
        plotWidgets[0]->updateSymbols();

			




	
	
	
		
 
        plotWidgets[0]->updateLegend();

			




	
	
	
		
 
        replot();

			




	
	
	
		
 
    }

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
void PlotManager::checkNoVisChannels()

			




	
	
	
		
 
{

			




	
	
	
		
 
    // if all channels are hidden show indicator

			




	
	
	
		
 
    bool allhidden = std::none_of(curves.cbegin(), curves.cend(),

			




	
	
	
		
 
                                  [](QwtPlotCurve* c) {return c->isVisible();});

			




	
	
	
		
 

			




	
	
	
		
 
    plotWidgets[0]->showNoChannel(allhidden);

			




	
	
	
		
 
    if (isMulti)

			




	
	
	
		
 
    {

			




	
	
	
		
 
        plotWidgets[0]->showNoChannel(allhidden);

			




	
	
	
		
 
        plotWidgets[0]->setVisible(true);

			




	
	
	
		
 
    }

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
void PlotManager::setMulti(bool enabled)

			




	
	
	
		
 
{

			




	
	
	
		
 
    if (enabled == isMulti) return;

			




	
	
	
		
 

			




	
	
	
		
 
    isMulti = enabled;

			




	
	
	
		
 

			




	
	
	
		
 
    // detach all curves

			




	
	
	
		
 
    for (auto curve : curves)

			




	
	
	
		
 
    {

			




	
	
	
		
 
        curve->detach();

			




	
	
	
		
 
    }

			




	
	
	
		
 

			




	
	
	
		
 
    // remove all widgets

			




	
	
	
		
 
    while (plotWidgets.size())

			




	
	
	
		
 
    {

			




	
	
	
		
 
        delete plotWidgets.takeLast();

			




	
	
	
		
 
    }

			




	
	
	
		
 

			




	
	
	
		
 
    // setup new layout

			




	
	
	
		
 
    setupLayout(isMulti);

			




	
	
	
		
 

			




	
	
	
		
 
    if (isMulti)

			




	
	
	
		
 
    {

			




	
	
	
		
 
        // add new widgets and attach

			




	
	
	
		
 
        for (auto curve : curves)

			




	
	
	
		
 
        {

			




	
	
	
		
 
            auto plot = addPlotWidget();

			




	
	
	
		
 
            plot->setVisible(curve->isVisible());

			




	
	
	
		
 
            curve->attach(plot);

			




	
	
	
		
 
        }

			




	
	
	
		
 
    }

			




	
	
	
		
 
    else

			




	
	
	
		
 
    {

			




	
	
	
		
 
        // add a single widget

			




	
	
	
		
 
        auto plot = addPlotWidget();

			




	
	
	
		
 

			




	
	
	
		
 
        // attach all curves

			




	
	
	
		
 
        for (auto curve : curves)

			




	
	
	
		
 
        {

			




	
	
	
		
 
            curve->attach(plot);

			




	
	
	
		
 
        }

			




	
	
	
		
 
    }

			




	
	
	
		
 

			




	
	
	
		
 
    // will skip if no plot widgets exist (can happen during constructor)

			




	
	
	
		
 
    if (plotWidgets.length())

			




	
	
	
		
 
    {

			




	
	
	
		
 
        checkNoVisChannels();

			




	
	
	
		
 
    }

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
void PlotManager::setupLayout(bool multiPlot)

			




	
	
	
		
 
{

			




	
	
	
		
 
    // delete previous layout if it exists

			




	
	
	
		
 
    if (_plotArea->layout() != 0)

			




	
	
	
		
 
    {

			




	
	
	
		
 
        delete _plotArea->layout();

			




	
	
	
		
 
    }

			




	
	
	
		
 

			




	
	
	
		
 
    if (multiPlot)

			




	
	
	
		
 
    {

			




	
	
	
		
 
        // setup a scroll area

			




	
	
	
		
 
        scrollArea = new QScrollArea();

			




	
	
	
		
 
        auto scrolledPlotArea = new QWidget(scrollArea);

			




	
	
	
		
 
        scrollArea->setWidget(scrolledPlotArea);

			




	
	
	
		
 
        scrollArea->setWidgetResizable(true);

			




	
	
	
		
 

			




	
	
	
		
 
        _plotArea->setLayout(new QVBoxLayout());

			




	
	
	
		
 
        _plotArea->layout()->addWidget(scrollArea);

			




	
	
	
		
 
        _plotArea->layout()->setContentsMargins(0,0,0,0);

			




	
	
	
		
 

			




	
	
	
		
 
        layout = new QVBoxLayout(scrolledPlotArea);

			




	
	
	
		
 
    }

			




	
	
	
		
 
    else

			




	
	
	
		
 
    {

			




	
	
	
		
 
        // delete scrollArea left from multi layout

			




	
	
	
		
 
        if (scrollArea != NULL)

			




	
	
	
		
 
        {

			




	
	
	
		
 
            delete scrollArea;

			




	
	
	
		
 
            scrollArea = NULL;

			




	
	
	
		
 
        }

			




	
	
	
		
 

			




	
	
	
		
 
        layout = new QVBoxLayout(_plotArea);

			




	
	
	
		
 
    }

			




	
	
	
		
 

			




	
	
	
		
 
    layout->setContentsMargins(2,2,2,2);

			




	
	
	
		
 
    layout->setSpacing(1);

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
Plot* PlotManager::addPlotWidget()

			




	
	
	
		
 
{

			




	
	
	
		
 
    auto plot = new Plot(_stream);

			




	
	
	
		
 
    plotWidgets.append(plot);

			




	
	
	
		
 
    layout->addWidget(plot);

			




	
	
	
		
 

			




	
	
	
		
 
    plot->darkBackground(_menu->darkBackgroundAction.isChecked());

			




	
	
	
		
 
    plot->showGrid(_menu->showGridAction.isChecked());

			




	
	
	
		
 
    plot->showMinorGrid(_menu->showMinorGridAction.isChecked());

			




	
	
	
		
 
    plot->showLegend(_menu->showLegendAction.isChecked());

			




	
	
	
		
 
    plot->setSymbols(_menu->showSymbols());

			




	
	
	
		
 

			




	
	
	
		
 
    plot->showDemoIndicator(isDemoShown);

			




	
	
	
		
 
    plot->setYAxis(_autoScaled, _yMin, _yMax);

			




	
	
	
		
 
    plot->setNumOfSamples(_numOfSamples);

			




	
	
	
		
 

			




	
	
	
		
 
    plot->setPlotWidth(_plotWidth);

			




	
	
	
		
 
    if (_xAxisAsIndex)

			




	
	
	
		
 
    {

			




	
	
	
		
 
        plot->setXAxis(0, _numOfSamples);

			




	
	
	
		
 
    }

			




	
	
	
		
 
    else

			




	
	
	
		
 
    {

			




	
	
	
		
 
        plot->setXAxis(_xMin, _xMax);

			




	
	
	
		
 
    }

			




	
	
	
		
 

			




	
	
	
		
 
    return plot;

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
void PlotManager::addCurve(QString title, const FrameBuffer* buffer)

			




	
	
	
		
 
void PlotManager::addCurve(QString title, const XFrameBuffer* xBuf, const FrameBuffer* yBuf)

			




	
	
	
		
 
{

			




	
	
	
		
 
    auto curve = new QwtPlotCurve(title);

			




	
	
	
		
 
    auto series = new FrameBufferSeries(buffer);

			




	
	
	
		
 
    series->setXAxis(_xAxisAsIndex, _xMin, _xMax);

			




	
	
	
		
 
    auto series = new FrameBufferSeries(xBuf, yBuf);

			




	
	
	
		
 
    curve->setSamples(series);

			




	
	
	
		
 
    _addCurve(curve);

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
void PlotManager::_addCurve(QwtPlotCurve* curve)

			




	
	
	
		
 
{

			




	
	
	
		
 
    // store and init the curve

			




	
	
	
		
 
    curves.append(curve);

			




	
	
	
		
 

			




	
	
	
		
 
    unsigned index = curves.size()-1;

			




	
	
	
		
 
    auto color = infoModel->color(index);

			




	
	
	
		
 
    curve->setPen(color);

			




	
	
	
		
 

			




	
	
	
		
 
    // create the plot for the curve if we are on multi display

			




	
	
	
		
 
    Plot* plot;

			




	
	
	
		
 
    if (isMulti)

			




	
	
	
		
 
    {

			




	
	
	
		
 
        // create a new plot widget

			




	
	
	
		
 
        plot = addPlotWidget();

			




	
	
	
		
 
    }

			




	
	
	
		
 
    else

			




	
	
	
		
 
    {

			




	
	
	
		
 
        plot = plotWidgets[0];

			




	
	
	
		
 
    }

			




	
	
	
		
 

			




	
	
	
		
 
    // show the curve

			




	
	
	
		
 
    curve->attach(plot);

			




	
	
	
		
 
    plot->replot();

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
void PlotManager::removeCurves(unsigned number)

			




	
	
	
		
 
{

			




	
	
	
		
 
    for (unsigned i = 0; i < number; i++)

			




	
	
	
		
 
    {

			




	
	
	
		
 
        if (!curves.isEmpty())

			




	
	
	
		
 
        {

			




	
	
	
		
 
            delete curves.takeLast();

			




	
	
	
		
 
            if (isMulti) // delete corresponding widget as well

			




	
	
	
		
 
            {

			




	
	
	
		
 
                delete plotWidgets.takeLast();

			




	
	
	
		
 
            }

			




	
	
	
		
 
        }

			




	
	
	
		
 
    }

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
unsigned PlotManager::numOfCurves()

			




	
	
	
		
 
{

			




	
	
	
		
 
    return curves.size();

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
Plot* PlotManager::plotWidget(unsigned curveIndex)

			




	
	
	
		
 
{

			




	
	
	
		
 
    if (isMulti)

			




	
	
	
		
 
    {

			




	
	
	
		
 
        return plotWidgets[curveIndex];

			




	
	
	
		
 
    }

			




	
	
	
		
 
    else

			




	
	
	
		
 
    {

			




	
	
	
		
 
        return plotWidgets[0];

			




	
	
	
		
 
    }

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
void PlotManager::replot()

			




	
	
	
		
 
{

			




	
	
	
		
 
    for (auto plot : plotWidgets)

			




	
	
	
		
 
    {

			




	
	
	
		
 
        plot->replot();

			




	
	
	
		
 
    }

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
void PlotManager::showGrid(bool show)

			




	
	
	
		
 
{

			




	
	
	
		
 
    for (auto plot : plotWidgets)

			




	
	
	
		
 
    {

			




	
	
	
		
 
        plot->showGrid(show);

			




	
	
	
		
 
    }

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
void PlotManager::showMinorGrid(bool show)

			




	
	
	
		
 
{

			




	
	
	
		
 
    for (auto plot : plotWidgets)

			




	
	
	
		
 
    {

			




	
	
	
		
 
        plot->showMinorGrid(show);

			




	
	
	
		
 
    }

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
void PlotManager::showLegend(bool show)

			




	
	
	
		
 
{

			




	
	
	
		
 
    for (auto plot : plotWidgets)

			




	
	
	
		
 
    {

			




	
	
	
		
 
        plot->showLegend(show);

			




	
	
	
		
 
    }

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
void PlotManager::showDemoIndicator(bool show)

			




	
	
	
		
 
{

			




	
	
	
		
 
    isDemoShown = show;

			




	
	
	
		
 
    for (auto plot : plotWidgets)

			




	
	
	
		
 
    {

			




	
	
	
		
 
        plot->showDemoIndicator(show);

			




	
	
	
		
 
    }

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
void PlotManager::unzoom()

			




	
	
	
		
 
{

			




	
	
	
		
 
    for (auto plot : plotWidgets)

			




	
	
	
		
 
    {

			




	
	
	
		
 
        plot->unzoom();

			




	
	
	
		
 
    }

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
void PlotManager::darkBackground(bool enabled)

			




	
	
	
		
 
{

			




	
	
	
		
 
    for (auto plot : plotWidgets)

			




	
	
	
		
 
    {

			




	
	
	
		
 
        plot->darkBackground(enabled);

			




	
	
	
		
 
    }

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
void PlotManager::setSymbols(Plot::ShowSymbols shown)

			




	
	
	
		
 
{

			




	
	
	
		
 
    showSymbols = shown;

			




	
	
	
		
 
    for (auto plot : plotWidgets)

			




	
	
	
		
 
    {

			




	
	
	
		
 
        plot->setSymbols(shown);

			




	
	
	
		
 
    }

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
void PlotManager::setYAxis(bool autoScaled, double yAxisMin, double yAxisMax)

			




	
	
	
		
 
{

			




	
	
	
		
 
    _autoScaled = autoScaled;

			




	
	
	
		
 
    _yMin = yAxisMin;

			




	
	
	
		
 
    _yMax = yAxisMax;

			




	
	
	
		
 
    for (auto plot : plotWidgets)

			




	
	
	
		
 
    {

			




	
	
	
		
 
        plot->setYAxis(autoScaled, yAxisMin, yAxisMax);

			




	
	
	
		
 
    }

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
void PlotManager::setXAxis(bool asIndex, double xMin, double xMax)

			




	
	
	
		
 
{

			




	
	
	
		
 
    _xAxisAsIndex = asIndex;

			




	
	
	
		
 
    _xMin = xMin;

			




	
	
	
		
 
    _xMax = xMax;

			




	
	
	
		
 

			




	
	
	
		
 
    int ci = 0;

			




	
	
	
		
 
    for (auto curve : curves)

			




	
	
	
		
 
    {

			




	
	
	
		
 
        FrameBufferSeries* series = static_cast<FrameBufferSeries*>(curve->data());

			




	
	
	
		
 
        series->setXAxis(asIndex, xMin, xMax);

			




	
	
	
		
 
        series->setX(_stream->channel(ci)->xData());

			




	
	
	
		
 
        ci++;

			




	
	
	
		
 
    }

			




	
	
	
		
 
    for (auto plot : plotWidgets)

			




	
	
	
		
 
    {

			




	
	
	
		
 
        if (asIndex)

			




	
	
	
		
 
        {

			




	
	
	
		
 
            plot->setXAxis(0, _numOfSamples);

			




	
	
	
		
 
        }

			




	
	
	
		
 
        else

			




	
	
	
		
 
        {

			




	
	
	
		
 
            plot->setXAxis(xMin, xMax);

			




	
	
	
		
 
        }

			




	
	
	
		
 
    }

			




	
	
	
		
 
    replot();

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
void PlotManager::flashSnapshotOverlay()

			




	
	
	
		
 
{

			




	
	
	
		
 
    for (auto plot : plotWidgets)

			




	
	
	
		
 
    {

			




	
	
	
		
 
        plot->flashSnapshotOverlay(_menu->darkBackgroundAction.isChecked());

			




	
	
	
		
 
    }

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
void PlotManager::setNumOfSamples(unsigned value)

			




	
	
	
		
 
{

			




	
	
	
		
 
    _numOfSamples = value;

			




	
	
	
		
 
    for (auto plot : plotWidgets)

			




	
	
	
		
 
    {

			




	
	
	
		
 
        plot->setNumOfSamples(value);

			




	
	
	
		
 
        if (_xAxisAsIndex) plot->setXAxis(0, value);

			




	
	
	
		
 
    }

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
void PlotManager::setPlotWidth(double width)

			




	
	
	
		
 
{

			




	
	
	
		
 
    _plotWidth = width;

			




	
	
	
		
 
    for (auto plot : plotWidgets)

			




	
	
	
		
 
    {

			




	
	
	
		
 
        plot->setPlotWidth(width);

			




	
	
	
		
 
    }

			




	
	
	
		
 
}

			




        

    


    
    

    

        

                

                    src/plotmanager.h
                

                

                  
                      
                        

                      ➞

                      
                        
                  

                  
                      
                  
                      
                  
                      
                  
                      
                  
                  
                

                

                    Show inline comments
                    
                

        

        

            



	
	
	
		
 
/*

			




	
	
	
		
 
  Copyright © 2018 Hasan Yavuz Özderya

			




	
	
	
		
 

			




	
	
	
		
 
  This file is part of serialplot.

			




	
	
	
		
 

			




	
	
	
		
 
  serialplot is free software: you can redistribute it and/or modify

			




	
	
	
		
 
  it under the terms of the GNU General Public License as published by

			




	
	
	
		
 
  the Free Software Foundation, either version 3 of the License, or

			




	
	
	
		
 
  (at your option) any later version.

			




	
	
	
		
 

			




	
	
	
		
 
  serialplot is distributed in the hope that it will be useful,

			




	
	
	
		
 
  but WITHOUT ANY WARRANTY; without even the implied warranty of

			




	
	
	
		
 
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

			




	
	
	
		
 
  GNU General Public License for more details.

			




	
	
	
		
 

			




	
	
	
		
 
  You should have received a copy of the GNU General Public License

			




	
	
	
		
 
  along with serialplot.  If not, see <http://www.gnu.org/licenses/>.

			




	
	
	
		
 
*/

			




	
	
	
		
 

			




	
	
	
		
 
#ifndef PLOTMANAGER_H

			




	
	
	
		
 
#define PLOTMANAGER_H

			




	
	
	
		
 

			




	
	
	
		
 
#include <QObject>

			




	
	
	
		
 
#include <QWidget>

			




	
	
	
		
 
#include <QScrollArea>

			




	
	
	
		
 
#include <QVBoxLayout>

			




	
	
	
		
 
#include <QList>

			




	
	
	
		
 
#include <QSettings>

			




	
	
	
		
 
#include <QMenu>

			




	
	
	
		
 

			




	
	
	
		
 
#include <qwt_plot_curve.h>

			




	
	
	
		
 
#include "plot.h"

			




	
	
	
		
 
#include "framebufferseries.h"

			




	
	
	
		
 
#include "stream.h"

			




	
	
	
		
 
#include "snapshot.h"

			




	
	
	
		
 
#include "plotmenu.h"

			




	
	
	
		
 

			




	
	
	
		
 
class PlotManager : public QObject

			




	
	
	
		
 
{

			




	
	
	
		
 
    Q_OBJECT

			




	
	
	
		
 

			




	
	
	
		
 
public:

			




	
	
	
		
 
    explicit PlotManager(QWidget* plotArea, PlotMenu* menu,

			




	
	
	
		
 
                         const Stream* stream = nullptr,

			




	
	
	
		
 
                         QObject *parent = 0);

			




	
	
	
		
 
    explicit PlotManager(QWidget* plotArea, PlotMenu* menu,

			




	
	
	
		
 
                         Snapshot* snapshot,

			




	
	
	
		
 
                         QObject *parent = 0);

			




	
	
	
		
 
    ~PlotManager();

			




	
	
	
		
 
    /// Add a new curve with title and buffer. A color is

			




	
	
	
		
 
    /// automatically chosen for curve.

			




	
	
	
		
 
    void addCurve(QString title, const FrameBuffer* buffer);

			




	
	
	
		
 
    void addCurve(QString title, const XFrameBuffer* xBuf, const FrameBuffer* yBuf);

			




	
	
	
		
 
    /// Removes curves from the end

			




	
	
	
		
 
    void removeCurves(unsigned number);

			




	
	
	
		
 
    /// Returns current number of curves known by plot manager

			




	
	
	
		
 
    unsigned numOfCurves();

			




	
	
	
		
 

			




	
	
	
		
 
public slots:

			




	
	
	
		
 
    /// Enable/Disable multiple plot display

			




	
	
	
		
 
    void setMulti(bool enabled);

			




	
	
	
		
 
    /// Update all plot widgets

			




	
	
	
		
 
    void replot();

			




	
	
	
		
 
    /// Enable display of a "DEMO" label on each plot

			




	
	
	
		
 
    void showDemoIndicator(bool show = true);

			




	
	
	
		
 
    /// Set the Y axis

			




	
	
	
		
 
    void setYAxis(bool autoScaled, double yMin = 0, double yMax = 1);

			




	
	
	
		
 
    /// Set the X axis

			




	
	
	
		
 
    void setXAxis(bool asIndex, double xMin = 0 , double xMax = 1);

			




	
	
	
		
 
    /// Display an animation for snapshot

			




	
	
	
		
 
    void flashSnapshotOverlay();

			




	
	
	
		
 
    /// Should be called to update zoom base

			




	
	
	
		
 
    void setNumOfSamples(unsigned value);

			




	
	
	
		
 
    /// Maximum width of X axis (limit of hscroll)

			




	
	
	
		
 
    void setPlotWidth(double width);

			




	
	
	
		
 

			




	
	
	
		
 
private:

			




	
	
	
		
 
    bool isMulti;

			




	
	
	
		
 
    QWidget* _plotArea;

			




	
	
	
		
 
    PlotMenu* _menu;

			




	
	
	
		
 
    QVBoxLayout* layout; ///< layout of the `plotArea`

			




	
	
	
		
 
    QScrollArea* scrollArea;

			




	
	
	
		
 
    QList<QwtPlotCurve*> curves;

			




	
	
	
		
 
    QList<Plot*> plotWidgets;

			




	
	
	
		
 
    Plot* emptyPlot;  ///< for displaying when all channels are hidden

			




	
	
	
		
 
    const Stream* _stream;       ///< attached stream, can be `nullptr`

			




	
	
	
		
 
    const ChannelInfoModel* infoModel;

			




	
	
	
		
 
    bool isDemoShown;

			




	
	
	
		
 
    bool _autoScaled;

			




	
	
	
		
 
    double _yMin;

			




	
	
	
		
 
    double _yMax;

			




	
	
	
		
 
    bool _xAxisAsIndex;

			




	
	
	
		
 
    double _xMin;

			




	
	
	
		
 
    double _xMax;

			




	
	
	
		
 
    unsigned _numOfSamples;

			




	
	
	
		
 
    double _plotWidth;

			




	
	
	
		
 
    Plot::ShowSymbols showSymbols;

			




	
	
	
		
 

			




	
	
	
		
 
    /// Common constructor

			




	
	
	
		
 
    void construct(QWidget* plotArea, PlotMenu* menu);

			




	
	
	
		
 
    /// Setups the layout for multi or single plot

			




	
	
	
		
 
    void setupLayout(bool multiPlot);

			




	
	
	
		
 
    /// Inserts a new plot widget to the current layout.

			




	
	
	
		
 
    Plot* addPlotWidget();

			




	
	
	
		
 
    /// Returns the plot widget that given curve is attached to

			




	
	
	
		
 
    Plot* plotWidget(unsigned curveIndex);

			




	
	
	
		
 
    /// Common part of overloaded `addCurve` functions

			




	
	
	
		
 
    void _addCurve(QwtPlotCurve* curve);

			




	
	
	
		
 
    /// Check and make sure "no visible channels" text is shown

			




	
	
	
		
 
    void checkNoVisChannels();

			




	
	
	
		
 

			




	
	
	
		
 
private slots:

			




	
	
	
		
 
    void showGrid(bool show = true);

			




	
	
	
		
 
    void showMinorGrid(bool show = true);

			




	
	
	
		
 
    void showLegend(bool show = true);

			




	
	
	
		
 
    void unzoom();

			




	
	
	
		
 
    void darkBackground(bool enabled = true);

			




	
	
	
		
 
    void setSymbols(Plot::ShowSymbols shown);

			




	
	
	
		
 

			




	
	
	
		
 
    void onNumChannelsChanged(unsigned value);

			




	
	
	
		
 
    void onChannelInfoChanged(const QModelIndex & topLeft,

			




	
	
	
		
 
                              const QModelIndex & bottomRight,

			




	
	
	
		
 
                              const QVector<int> & roles = QVector<int> ());

			




	
	
	
		
 
};

			




	
	
	
		
 

			




	
	
	
		
 
#endif // PLOTMANAGER_H

			




        

    


    
    

    

        

                

                    src/snapshot.h
                

                

                  
                      
                        

                      ➞

                      
                        
                  

                  
                      
                  
                      
                  
                      
                  
                      
                  
                  
                

                

                    Show inline comments
                    
                

        

        

            



	
	
	
		
 
/*

			




	
	
	
		
 
  Copyright © 2018 Hasan Yavuz Özderya

			




	
	
	
		
 

			




	
	
	
		
 
  This file is part of serialplot.

			




	
	
	
		
 

			




	
	
	
		
 
  serialplot is free software: you can redistribute it and/or modify

			




	
	
	
		
 
  it under the terms of the GNU General Public License as published by

			




	
	
	
		
 
  the Free Software Foundation, either version 3 of the License, or

			




	
	
	
		
 
  (at your option) any later version.

			




	
	
	
		
 

			




	
	
	
		
 
  serialplot is distributed in the hope that it will be useful,

			




	
	
	
		
 
  but WITHOUT ANY WARRANTY; without even the implied warranty of

			




	
	
	
		
 
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

			




	
	
	
		
 
  GNU General Public License for more details.

			




	
	
	
		
 

			




	
	
	
		
 
  You should have received a copy of the GNU General Public License

			




	
	
	
		
 
  along with serialplot.  If not, see <http://www.gnu.org/licenses/>.

			




	
	
	
		
 
*/

			




	
	
	
		
 

			




	
	
	
		
 
#ifndef SNAPSHOT_H

			




	
	
	
		
 
#define SNAPSHOT_H

			




	
	
	
		
 

			




	
	
	
		
 
#include <QObject>

			




	
	
	
		
 
#include <QAction>

			




	
	
	
		
 
#include <QVector>

			




	
	
	
		
 
#include <QString>

			




	
	
	
		
 
#include <QStringList>

			




	
	
	
		
 

			




	
	
	
		
 
#include "channelinfomodel.h"

			




	
	
	
		
 
#include "readonlybuffer.h"

			




	
	
	
		
 
#include "indexbuffer.h"

			




	
	
	
		
 

			




	
	
	
		
 
class SnapshotView;

			




	
	
	
		
 
class MainWindow;

			




	
	
	
		
 

			




	
	
	
		
 
class Snapshot : public QObject

			




	
	
	
		
 
{

			




	
	
	
		
 
    Q_OBJECT

			




	
	
	
		
 

			




	
	
	
		
 
public:

			




	
	
	
		
 
    Snapshot(MainWindow* parent, QString name, ChannelInfoModel infoModel, bool saved = false);

			




	
	
	
		
 
    ~Snapshot();

			




	
	
	
		
 

			




	
	
	
		
 
    // TODO: yData of snapshot shouldn't be public, preferable should be handled in constructor

			




	
	
	
		
 
    // TODO: yData and xData of snapshot shouldn't be public, preferable should be handled in constructor

			




	
	
	
		
 
    QVector<IndexBuffer*> xData;

			




	
	
	
		
 
    QVector<ReadOnlyBuffer*> yData;

			




	
	
	
		
 
    QAction* showAction();

			




	
	
	
		
 
    QAction* deleteAction();

			




	
	
	
		
 

			




	
	
	
		
 
    QString name();

			




	
	
	
		
 
    QString displayName(); ///< `name()` plus '*' if snapshot is not saved

			




	
	
	
		
 
    unsigned numChannels() const; ///< number of channels in this snapshot

			




	
	
	
		
 
    unsigned numSamples() const;  ///< number of samples in every channel

			




	
	
	
		
 
    const ChannelInfoModel* infoModel() const;

			




	
	
	
		
 
    ChannelInfoModel* infoModel();

			




	
	
	
		
 
    void setName(QString name);

			




	
	
	
		
 
    QString channelName(unsigned channel);

			




	
	
	
		
 

			




	
	
	
		
 
    void save(QString fileName); ///< save snapshot data as CSV

			




	
	
	
		
 
    bool isSaved(); ///< snapshot has been saved at least once

			




	
	
	
		
 

			




	
	
	
		
 
signals:

			




	
	
	
		
 
    void deleteRequested(Snapshot*);

			




	
	
	
		
 
    void nameChanged(Snapshot*);

			




	
	
	
		
 

			




	
	
	
		
 
private:

			




	
	
	
		
 
    QString _name;

			




	
	
	
		
 
    ChannelInfoModel cInfoModel;

			




	
	
	
		
 
    QAction _showAction;

			




	
	
	
		
 
    QAction _deleteAction;

			




	
	
	
		
 
    MainWindow* mainWindow;

			




	
	
	
		
 
    SnapshotView* view;

			




	
	
	
		
 
    bool _saved;

			




	
	
	
		
 

			




	
	
	
		
 
private slots:

			




	
	
	
		
 
    void show();

			




	
	
	
		
 
    void viewClosed();

			




	
	
	
		
 

			




	
	
	
		
 
    void onDeleteTriggered();

			




	
	
	
		
 
};

			




	
	
	
		
 

			




	
	
	
		
 
#endif /* SNAPSHOT_H */

			




        

    


    
    

    

        

                

                    src/snapshotmanager.cpp
                

                

                  
                      
                        

                      ➞

                      
                        
                  

                  
                      
                  
                      
                  
                      
                  
                      
                  
                  
                

                

                    Show inline comments
                    
                

        

        

            



	
	
	
		
 
/*

			




	
	
	
		
 
  Copyright © 2018 Hasan Yavuz Özderya

			




	
	
	
		
 

			




	
	
	
		
 
  This file is part of serialplot.

			




	
	
	
		
 

			




	
	
	
		
 
  serialplot is free software: you can redistribute it and/or modify

			




	
	
	
		
 
  it under the terms of the GNU General Public License as published by

			




	
	
	
		
 
  the Free Software Foundation, either version 3 of the License, or

			




	
	
	
		
 
  (at your option) any later version.

			




	
	
	
		
 

			




	
	
	
		
 
  serialplot is distributed in the hope that it will be useful,

			




	
	
	
		
 
  but WITHOUT ANY WARRANTY; without even the implied warranty of

			




	
	
	
		
 
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

			




	
	
	
		
 
  GNU General Public License for more details.

			




	
	
	
		
 

			




	
	
	
		
 
  You should have received a copy of the GNU General Public License

			




	
	
	
		
 
  along with serialplot.  If not, see <http://www.gnu.org/licenses/>.

			




	
	
	
		
 
*/

			




	
	
	
		
 

			




	
	
	
		
 
#include <QTime>

			




	
	
	
		
 
#include <QMenuBar>

			




	
	
	
		
 
#include <QKeySequence>

			




	
	
	
		
 
#include <QFileDialog>

			




	
	
	
		
 
#include <QFile>

			




	
	
	
		
 
#include <QTextStream>

			




	
	
	
		
 
#include <QVector>

			




	
	
	
		
 
#include <QPointF>

			




	
	
	
		
 
#include <QIcon>

			




	
	
	
		
 
#include <QtDebug>

			




	
	
	
		
 

			




	
	
	
		
 
#include "mainwindow.h"

			




	
	
	
		
 
#include "snapshotmanager.h"

			




	
	
	
		
 

			




	
	
	
		
 
SnapshotManager::SnapshotManager(MainWindow* mainWindow,

			




	
	
	
		
 
                                 Stream* stream) :

			




	
	
	
		
 
    _menu("&Snapshots"),

			




	
	
	
		
 
    _takeSnapshotAction("&Take Snapshot", this),

			




	
	
	
		
 
    loadSnapshotAction("&Load Snapshots", this),

			




	
	
	
		
 
    clearAction("&Clear Snapshots", this)

			




	
	
	
		
 
{

			




	
	
	
		
 
    _mainWindow = mainWindow;

			




	
	
	
		
 
    _stream = stream;

			




	
	
	
		
 

			




	
	
	
		
 
    _takeSnapshotAction.setToolTip("Take a snapshot of current plot");

			




	
	
	
		
 
    _takeSnapshotAction.setShortcut(QKeySequence("F5"));

			




	
	
	
		
 
    _takeSnapshotAction.setIcon(QIcon::fromTheme("camera"));

			




	
	
	
		
 
    loadSnapshotAction.setToolTip("Load snapshots from CSV files");

			




	
	
	
		
 
    clearAction.setToolTip("Delete all snapshots");

			




	
	
	
		
 
    connect(&_takeSnapshotAction, SIGNAL(triggered(bool)),

			




	
	
	
		
 
            this, SLOT(takeSnapshot()));

			




	
	
	
		
 
    connect(&clearAction, SIGNAL(triggered(bool)),

			




	
	
	
		
 
            this, SLOT(clearSnapshots()));

			




	
	
	
		
 
    connect(&loadSnapshotAction, SIGNAL(triggered(bool)),

			




	
	
	
		
 
            this, SLOT(loadSnapshots()));

			




	
	
	
		
 

			




	
	
	
		
 
    updateMenu();

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
SnapshotManager::~SnapshotManager()

			




	
	
	
		
 
{

			




	
	
	
		
 
    for (auto snapshot : snapshots)

			




	
	
	
		
 
    {

			




	
	
	
		
 
        delete snapshot;

			




	
	
	
		
 
    }

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
Snapshot* SnapshotManager::makeSnapshot() const

			




	
	
	
		
 
{

			




	
	
	
		
 
    QString name = QTime::currentTime().toString("'Snapshot ['HH:mm:ss']'");

			




	
	
	
		
 
    auto snapshot = new Snapshot(_mainWindow, name, *(_stream->infoModel()));

			




	
	
	
		
 

			




	
	
	
		
 
    for (unsigned ci = 0; ci < _stream->numChannels(); ci++)

			




	
	
	
		
 
    {

			




	
	
	
		
 
        snapshot->xData.append(new IndexBuffer(_stream->numSamples()));

			




	
	
	
		
 
        snapshot->yData.append(new ReadOnlyBuffer(_stream->channel(ci)->yData()));

			




	
	
	
		
 
    }

			




	
	
	
		
 

			




	
	
	
		
 
    return snapshot;

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
void SnapshotManager::takeSnapshot()

			




	
	
	
		
 
{

			




	
	
	
		
 
    addSnapshot(makeSnapshot());

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
void SnapshotManager::addSnapshot(Snapshot* snapshot, bool update_menu)

			




	
	
	
		
 
{

			




	
	
	
		
 
    snapshots.append(snapshot);

			




	
	
	
		
 
    QObject::connect(snapshot, &Snapshot::deleteRequested,

			




	
	
	
		
 
                     this, &SnapshotManager::deleteSnapshot);

			




	
	
	
		
 
    if (update_menu) updateMenu();

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
void SnapshotManager::updateMenu()

			




	
	
	
		
 
{

			




	
	
	
		
 
    _menu.clear();

			




	
	
	
		
 
    _menu.addAction(&_takeSnapshotAction);

			




	
	
	
		
 
    _menu.addAction(&loadSnapshotAction);

			




	
	
	
		
 
    if (snapshots.size())

			




	
	
	
		
 
    {

			




	
	
	
		
 
        _menu.addSeparator();

			




	
	
	
		
 
        for (auto ss : snapshots)

			




	
	
	
		
 
        {

			




	
	
	
		
 
            _menu.addAction(ss->showAction());

			




	
	
	
		
 
        }

			




	
	
	
		
 
        _menu.addSeparator();

			




	
	
	
		
 
        _menu.addAction(&clearAction);

			




	
	
	
		
 
    }

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
void SnapshotManager::clearSnapshots()

			




	
	
	
		
 
{

			




	
	
	
		
 
    for (auto snapshot : snapshots)

			




	
	
	
		
 
    {

			




	
	
	
		
 
        delete snapshot;

			




	
	
	
		
 
    }

			




	
	
	
		
 
    snapshots.clear();

			




	
	
	
		
 
    updateMenu();

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
void SnapshotManager::deleteSnapshot(Snapshot* snapshot)

			




	
	
	
		
 
{

			




	
	
	
		
 
    snapshots.removeOne(snapshot);

			




	
	
	
		
 
    snapshot->deleteLater(); // regular delete causes a crash when triggered from menu

			




	
	
	
		
 
    updateMenu();

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
void SnapshotManager::loadSnapshots()

			




	
	
	
		
 
{

			




	
	
	
		
 
    auto files = QFileDialog::getOpenFileNames(_mainWindow, tr("Load CSV File"));

			




	
	
	
		
 

			




	
	
	
		
 
    for (auto f : files)

			




	
	
	
		
 
    {

			




	
	
	
		
 
        if (!f.isNull()) loadSnapshotFromFile(f);

			




	
	
	
		
 
    }

			




	
	
	
		
 

			




	
	
	
		
 
    updateMenu();

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
void SnapshotManager::loadSnapshotFromFile(QString fileName)

			




	
	
	
		
 
{

			




	
	
	
		
 
    QFile file(fileName);

			




	
	
	
		
 
    if (!file.open(QIODevice::ReadOnly | QIODevice::Text))

			




	
	
	
		
 
    {

			




	
	
	
		
 
        qCritical() << "Couldn't open file: " << fileName;

			




	
	
	
		
 
        qCritical() << file.errorString();

			




	
	
	
		
 
        return;

			




	
	
	
		
 
    }

			




	
	
	
		
 

			




	
	
	
		
 
    // read first row as headlines and determine number of channels

			




	
	
	
		
 
    auto headLine = QString(file.readLine());

			




	
	
	
		
 
    QStringList channelNames = headLine.split(',');

			




	
	
	
		
 
    unsigned numOfChannels = channelNames.size();

			




	
	
	
		
 

			




	
	
	
		
 
    // read data

			




	
	
	
		
 
    QVector<QVector<double>> data(numOfChannels);

			




	
	
	
		
 
    QTextStream ts(&file);

			




	
	
	
		
 
    QString line;

			




	
	
	
		
 
    unsigned lineNum = 1;

			




	
	
	
		
 
    while (ts.readLineInto(&line))

			




	
	
	
		
 
    {

			




	
	
	
		
 
        // parse line

			




	
	
	
		
 
        auto split = line.split(',');

			




	
	
	
		
 

			




	
	
	
		
 
        if (split.size() != (int) numOfChannels)

			




	
	
	
		
 
        {

			




	
	
	
		
 
            qCritical() << "Parsing error at line " << lineNum

			




	
	
	
		
 
                        << ": number of columns is not consistent.";

			




	
	
	
		
 
            qCritical() << "Line " << lineNum << ": " << line;

			




	
	
	
		
 
            return;

			




	
	
	
		
 
        }

			




	
	
	
		
 

			




	
	
	
		
 
        for (unsigned ci = 0; ci < numOfChannels; ci++)

			




	
	
	
		
 
        {

			




	
	
	
		
 
            // parse column

			




	
	
	
		
 
            bool ok;

			




	
	
	
		
 
            double y = split[ci].toDouble(&ok);

			




	
	
	
		
 
            if (!ok)

			




	
	
	
		
 
            {

			




	
	
	
		
 
                qCritical() << "Parsing error at line " << lineNum

			




	
	
	
		
 
                            << ", column " << ci

			




	
	
	
		
 
                            << ": can't convert \"" << split[ci]

			




	
	
	
		
 
                            << "\" to double.";

			




	
	
	
		
 
                return;

			




	
	
	
		
 
            }

			




	
	
	
		
 
            data[ci].append(y);

			




	
	
	
		
 
        }

			




	
	
	
		
 
        lineNum++;

			




	
	
	
		
 
    }

			




	
	
	
		
 

			




	
	
	
		
 
    // create snapshot

			




	
	
	
		
 
    auto snapshot = new Snapshot(

			




	
	
	
		
 
        _mainWindow, QFileInfo(fileName).baseName(),

			




	
	
	
		
 
        ChannelInfoModel(channelNames), true);

			




	
	
	
		
 

			




	
	
	
		
 
    for (unsigned ci = 0; ci < numOfChannels; ci++)

			




	
	
	
		
 
    {

			




	
	
	
		
 
        snapshot->xData.append(new IndexBuffer(data[ci].size()));

			




	
	
	
		
 
        snapshot->yData.append(new ReadOnlyBuffer(data[ci].data(), data[ci].size()));

			




	
	
	
		
 
    }

			




	
	
	
		
 

			




	
	
	
		
 
    addSnapshot(snapshot, false);

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
QMenu* SnapshotManager::menu()

			




	
	
	
		
 
{

			




	
	
	
		
 
    return &_menu;

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
QAction* SnapshotManager::takeSnapshotAction()

			




	
	
	
		
 
{

			




	
	
	
		
 
    return &_takeSnapshotAction;

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
bool SnapshotManager::isAllSaved()

			




	
	
	
		
 
{

			




	
	
	
		
 
    for (auto snapshot : snapshots)

			




	
	
	
		
 
    {

			




	
	
	
		
 
        if (!snapshot->isSaved()) return false;

			




	
	
	
		
 
    }

			




	
	
	
		
 
    return true;

			




	
	
	
		
 
}

			




        

    


    
    

    

        

                

                    src/stream.cpp
                

                

                  
                      
                        

                      ➞

                      
                        
                  

                  
                      
                  
                      
                  
                      
                  
                      
                  
                  
                

                

                    Show inline comments
                    
                

        

        

            



	
	
	
		
 
/*

			




	
	
	
		
 
  Copyright © 2018 Hasan Yavuz Özderya

			




	
	
	
		
 

			




	
	
	
		
 
  This file is part of serialplot.

			




	
	
	
		
 

			




	
	
	
		
 
  serialplot is free software: you can redistribute it and/or modify

			




	
	
	
		
 
  it under the terms of the GNU General Public License as published by

			




	
	
	
		
 
  the Free Software Foundation, either version 3 of the License, or

			




	
	
	
		
 
  (at your option) any later version.

			




	
	
	
		
 

			




	
	
	
		
 
  serialplot is distributed in the hope that it will be useful,

			




	
	
	
		
 
  but WITHOUT ANY WARRANTY; without even the implied warranty of

			




	
	
	
		
 
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

			




	
	
	
		
 
  GNU General Public License for more details.

			




	
	
	
		
 

			




	
	
	
		
 
  You should have received a copy of the GNU General Public License

			




	
	
	
		
 
  along with serialplot.  If not, see <http://www.gnu.org/licenses/>.

			




	
	
	
		
 
*/

			




	
	
	
		
 

			




	
	
	
		
 
#include "stream.h"

			




	
	
	
		
 
#include "ringbuffer.h"

			




	
	
	
		
 
#include "indexbuffer.h"

			




	
	
	
		
 
#include "linindexbuffer.h"

			




	
	
	
		
 

			




	
	
	
		
 
Stream::Stream(unsigned nc, bool x, unsigned ns) :

			




	
	
	
		
 
    _infoModel(nc)

			




	
	
	
		
 
{

			




	
	
	
		
 
    _numSamples = ns;

			




	
	
	
		
 
    _paused = false;

			




	
	
	
		
 

			




	
	
	
		
 
    xAsIndex = true;

			




	
	
	
		
 
    xMin = 0;

			




	
	
	
		
 
    xMax = 1;

			




	
	
	
		
 

			




	
	
	
		
 
    // create xdata buffer

			




	
	
	
		
 
    _hasx = x;

			




	
	
	
		
 
    if (x)

			




	
	
	
		
 
    {

			




	
	
	
		
 
        // TODO: implement XRingBuffer (binary search)

			




	
	
	
		
 
        Q_ASSERT(false);

			




	
	
	
		
 
    }

			




	
	
	
		
 
    else

			




	
	
	
		
 
    {

			




	
	
	
		
 
        xData = new IndexBuffer(ns);

			




	
	
	
		
 
        xData = makeXBuffer();

			




	
	
	
		
 
    }

			




	
	
	
		
 

			




	
	
	
		
 
    // create channels

			




	
	
	
		
 
    for (unsigned i = 0; i < nc; i++)

			




	
	
	
		
 
    {

			




	
	
	
		
 
        auto c = new StreamChannel(i, xData, new RingBuffer(ns), &_infoModel);

			




	
	
	
		
 
        channels.append(c);

			




	
	
	
		
 
    }

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
Stream::~Stream()

			




	
	
	
		
 
{

			




	
	
	
		
 
    for (auto ch : channels)

			




	
	
	
		
 
    {

			




	
	
	
		
 
        delete ch;

			




	
	
	
		
 
    }

			




	
	
	
		
 
    delete xData;

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
bool Stream::hasX() const

			




	
	
	
		
 
{

			




	
	
	
		
 
    return _hasx;

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
unsigned Stream::numChannels() const

			




	
	
	
		
 
{

			




	
	
	
		
 
    return channels.length();

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
unsigned Stream::numSamples() const

			




	
	
	
		
 
{

			




	
	
	
		
 
    return _numSamples;

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
const StreamChannel* Stream::channel(unsigned index) const

			




	
	
	
		
 
{

			




	
	
	
		
 
    Q_ASSERT(index < numChannels());

			




	
	
	
		
 
    return channels[index];

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
StreamChannel* Stream::channel(unsigned index)

			




	
	
	
		
 
{

			




	
	
	
		
 
    return const_cast<StreamChannel*>(static_cast<const Stream&>(*this).channel(index));

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
const ChannelInfoModel* Stream::infoModel() const

			




	
	
	
		
 
{

			




	
	
	
		
 
    return &_infoModel;

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
ChannelInfoModel* Stream::infoModel()

			




	
	
	
		
 
{

			




	
	
	
		
 
    return const_cast<ChannelInfoModel*>(static_cast<const Stream&>(*this).infoModel());

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
void Stream::setNumChannels(unsigned nc, bool x)

			




	
	
	
		
 
{

			




	
	
	
		
 
    unsigned oldNum = numChannels();

			




	
	
	
		
 
    if (oldNum == nc && x == _hasx) return;

			




	
	
	
		
 

			




	
	
	
		
 
    // adjust the number of channels

			




	
	
	
		
 
    if (nc > oldNum)

			




	
	
	
		
 
    {

			




	
	
	
		
 
        for (unsigned i = oldNum; i < nc; i++)

			




	
	
	
		
 
        {

			




	
	
	
		
 
            auto c = new StreamChannel(i, xData, new RingBuffer(_numSamples), &_infoModel);

			




	
	
	
		
 
            channels.append(c);

			




	
	
	
		
 
        }

			




	
	
	
		
 
    }

			




	
	
	
		
 
    else if (nc < oldNum)

			




	
	
	
		
 
    {

			




	
	
	
		
 
        for (unsigned i = oldNum-1; i > nc-1; i--)

			




	
	
	
		
 
        {

			




	
	
	
		
 
            delete channels.takeLast();

			




	
	
	
		
 
        }

			




	
	
	
		
 
    }

			




	
	
	
		
 

			




	
	
	
		
 
    // change the xdata

			




	
	
	
		
 
    if (x != _hasx)

			




	
	
	
		
 
    {

			




	
	
	
		
 
        if (x)

			




	
	
	
		
 
        {

			




	
	
	
		
 
            // TODO: implement XRingBuffer (binary search)

			




	
	
	
		
 
            Q_ASSERT(false);

			




	
	
	
		
 
        }

			




	
	
	
		
 
        else

			




	
	
	
		
 
        {

			




	
	
	
		
 
            xData = new IndexBuffer(_numSamples);

			




	
	
	
		
 
            xData = makeXBuffer();

			




	
	
	
		
 
        }

			




	
	
	
		
 

			




	
	
	
		
 
        for (auto c : channels)

			




	
	
	
		
 
        {

			




	
	
	
		
 
            c->setX(xData);

			




	
	
	
		
 
        }

			




	
	
	
		
 
        _hasx = x;

			




	
	
	
		
 
    }

			




	
	
	
		
 

			




	
	
	
		
 
    if (nc != oldNum)

			




	
	
	
		
 
    {

			




	
	
	
		
 
        _infoModel.setNumOfChannels(nc);

			




	
	
	
		
 
        // TODO: how about X change?

			




	
	
	
		
 
        emit numChannelsChanged(nc);

			




	
	
	
		
 
    }

			




	
	
	
		
 

			




	
	
	
		
 
    Sink::setNumChannels(nc, x);

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
XFrameBuffer* Stream::makeXBuffer() const

			




	
	
	
		
 
{

			




	
	
	
		
 
    if (xAsIndex)

			




	
	
	
		
 
    {

			




	
	
	
		
 
        return new IndexBuffer(_numSamples);

			




	
	
	
		
 
    }

			




	
	
	
		
 
    else

			




	
	
	
		
 
    {

			




	
	
	
		
 
        return new LinIndexBuffer(_numSamples, xMin, xMax);

			




	
	
	
		
 
    }

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
const SamplePack* Stream::applyGainOffset(const SamplePack& pack) const

			




	
	
	
		
 
{

			




	
	
	
		
 
    Q_ASSERT(infoModel()->gainOrOffsetEn());

			




	
	
	
		
 

			




	
	
	
		
 
    SamplePack* mPack = new SamplePack(pack);

			




	
	
	
		
 
    unsigned ns = pack.numSamples();

			




	
	
	
		
 

			




	
	
	
		
 
    for (unsigned ci = 0; ci < numChannels(); ci++)

			




	
	
	
		
 
    {

			




	
	
	
		
 
        // TODO: we could use some kind of map (int32, int64 would suffice) to speed things up

			




	
	
	
		
 
        bool gainEn = infoModel()->gainEn(ci);

			




	
	
	
		
 
        bool offsetEn = infoModel()->offsetEn(ci);

			




	
	
	
		
 
        if (gainEn || offsetEn)

			




	
	
	
		
 
        {

			




	
	
	
		
 
            double* mdata = mPack->data(ci);

			




	
	
	
		
 

			




	
	
	
		
 
            double gain = infoModel()->gain(ci);

			




	
	
	
		
 
            double offset = infoModel()->offset(ci);

			




	
	
	
		
 

			




	
	
	
		
 
            if (gainEn)

			




	
	
	
		
 
            {

			




	
	
	
		
 
                for (unsigned i = 0; i < ns; i++)

			




	
	
	
		
 
                {

			




	
	
	
		
 
                    mdata[i] *= gain;

			




	
	
	
		
 
                }

			




	
	
	
		
 
            }

			




	
	
	
		
 
            if (offsetEn)

			




	
	
	
		
 
            {

			




	
	
	
		
 
                for (unsigned i = 0; i < ns; i++)

			




	
	
	
		
 
                {

			




	
	
	
		
 
                    mdata[i] += offset;

			




	
	
	
		
 
                }

			




	
	
	
		
 
            }

			




	
	
	
		
 
        }

			




	
	
	
		
 
    }

			




	
	
	
		
 

			




	
	
	
		
 
    return mPack;

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
void Stream::feedIn(const SamplePack& pack)

			




	
	
	
		
 
{

			




	
	
	
		
 
    Q_ASSERT(pack.numChannels() == numChannels() &&

			




	
	
	
		
 
             pack.hasX() == hasX());

			




	
	
	
		
 

			




	
	
	
		
 
    if (_paused) return;

			




	
	
	
		
 

			




	
	
	
		
 
    unsigned ns = pack.numSamples();

			




	
	
	
		
 
    if (_hasx)

			




	
	
	
		
 
    {

			




	
	
	
		
 
        // TODO: implement XRingBuffer (binary search)

			




	
	
	
		
 
        Q_ASSERT(false);

			




	
	
	
		
 
        // static_cast<RingBuffer*>(xData)->addSamples(pack.xData(), ns);

			




	
	
	
		
 
    }

			




	
	
	
		
 

			




	
	
	
		
 
    // modified pack that gain and offset is applied to

			




	
	
	
		
 
    const SamplePack* mPack = nullptr;

			




	
	
	
		
 
    if (infoModel()->gainOrOffsetEn())

			




	
	
	
		
 
        mPack = applyGainOffset(pack);

			




	
	
	
		
 

			




	
	
	
		
 
    for (unsigned ci = 0; ci < numChannels(); ci++)

			




	
	
	
		
 
    {

			




	
	
	
		
 
        auto buf = static_cast<RingBuffer*>(channels[ci]->yData());

			




	
	
	
		
 
        double* data = (mPack == nullptr) ? pack.data(ci) : mPack->data(ci);

			




	
	
	
		
 
        buf->addSamples(data, ns);

			




	
	
	
		
 
    }

			




	
	
	
		
 

			




	
	
	
		
 
    Sink::feedIn((mPack == nullptr) ? pack : *mPack);

			




	
	
	
		
 

			




	
	
	
		
 
    if (mPack != nullptr) delete mPack;

			




	
	
	
		
 
    emit dataAdded();

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
void Stream::pause(bool paused)

			




	
	
	
		
 
{

			




	
	
	
		
 
    _paused = paused;

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
void Stream::clear()

			




	
	
	
		
 
{

			




	
	
	
		
 
    for (auto c : channels)

			




	
	
	
		
 
    {

			




	
	
	
		
 
        static_cast<RingBuffer*>(c->yData())->clear();

			




	
	
	
		
 
    }

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
void Stream::setNumSamples(unsigned value)

			




	
	
	
		
 
{

			




	
	
	
		
 
    if (value == _numSamples) return;

			




	
	
	
		
 
    _numSamples = value;

			




	
	
	
		
 

			




	
	
	
		
 
    xData->resize(value);

			




	
	
	
		
 
    for (auto c : channels)

			




	
	
	
		
 
    {

			




	
	
	
		
 
        static_cast<RingBuffer*>(c->yData())->resize(value);

			




	
	
	
		
 
    }

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
void Stream::setXAxis(bool asIndex, double min, double max)

			




	
	
	
		
 
{

			




	
	
	
		
 
    xAsIndex = asIndex;

			




	
	
	
		
 
    xMin = min;

			




	
	
	
		
 
    xMax = max;

			




	
	
	
		
 

			




	
	
	
		
 
    // Note that x axis scaling is ignored when X is provided from source as data

			




	
	
	
		
 
    // TODO: assert (UI options for x axis should be disabled)

			




	
	
	
		
 
    if (!hasX())

			




	
	
	
		
 
    {

			




	
	
	
		
 
        xData = makeXBuffer();

			




	
	
	
		
 
        for (auto c : channels)

			




	
	
	
		
 
        {

			




	
	
	
		
 
            c->setX(xData);

			




	
	
	
		
 
        }

			




	
	
	
		
 
    }

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
void Stream::saveSettings(QSettings* settings) const

			




	
	
	
		
 
{

			




	
	
	
		
 
    _infoModel.saveSettings(settings);

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
void Stream::loadSettings(QSettings* settings)

			




	
	
	
		
 
{

			




	
	
	
		
 
    _infoModel.loadSettings(settings);

			




	
	
	
		
 
}

			




        

    


    
    

    

        

                

                    src/stream.h
                

                

                  
                      
                        

                      ➞

                      
                        
                  

                  
                      
                  
                      
                  
                      
                  
                      
                  
                  
                

                

                    Show inline comments
                    
                

        

        

            



	
	
	
		
 
/*

			




	
	
	
		
 
  Copyright © 2018 Hasan Yavuz Özderya

			




	
	
	
		
 

			




	
	
	
		
 
  This file is part of serialplot.

			




	
	
	
		
 

			




	
	
	
		
 
  serialplot is free software: you can redistribute it and/or modify

			




	
	
	
		
 
  it under the terms of the GNU General Public License as published by

			




	
	
	
		
 
  the Free Software Foundation, either version 3 of the License, or

			




	
	
	
		
 
  (at your option) any later version.

			




	
	
	
		
 

			




	
	
	
		
 
  serialplot is distributed in the hope that it will be useful,

			




	
	
	
		
 
  but WITHOUT ANY WARRANTY; without even the implied warranty of

			




	
	
	
		
 
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

			




	
	
	
		
 
  GNU General Public License for more details.

			




	
	
	
		
 

			




	
	
	
		
 
  You should have received a copy of the GNU General Public License

			




	
	
	
		
 
  along with serialplot.  If not, see <http://www.gnu.org/licenses/>.

			




	
	
	
		
 
*/

			




	
	
	
		
 

			




	
	
	
		
 
#ifndef STREAM_H

			




	
	
	
		
 
#define STREAM_H

			




	
	
	
		
 

			




	
	
	
		
 
#include <QObject>

			




	
	
	
		
 
#include <QModelIndex>

			




	
	
	
		
 
#include <QVector>

			




	
	
	
		
 
#include <QSettings>

			




	
	
	
		
 

			




	
	
	
		
 
#include "sink.h"

			




	
	
	
		
 
#include "source.h"

			




	
	
	
		
 
#include "channelinfomodel.h"

			




	
	
	
		
 
#include "streamchannel.h"

			




	
	
	
		
 
#include "framebuffer.h"

			




	
	
	
		
 

			




	
	
	
		
 
/**

			




	
	
	
		
 
 * Main waveform storage class. It consists of channels. Channels are

			




	
	
	
		
 
 * synchronized with each other.

			




	
	
	
		
 
 *

			




	
	
	
		
 
 * Implements `Sink` class for data entry. It's expected to be

			




	
	
	
		
 
 * connected to a `Device` source.

			




	
	
	
		
 
 */

			




	
	
	
		
 
class Stream : public QObject, public Sink

			




	
	
	
		
 
{

			




	
	
	
		
 
    Q_OBJECT

			




	
	
	
		
 

			




	
	
	
		
 
public:

			




	
	
	
		
 
    /**

			




	
	
	
		
 
     * @param nc number of channels

			




	
	
	
		
 
     * @param x has X data input

			




	
	
	
		
 
     * @param ns number of samples

			




	
	
	
		
 
     */

			




	
	
	
		
 
    Stream(unsigned nc = 0, bool x = false, unsigned ns = 0);

			




	
	
	
		
 
    Stream(unsigned nc = 1, bool x = false, unsigned ns = 2);

			




	
	
	
		
 
    ~Stream();

			




	
	
	
		
 

			




	
	
	
		
 
    bool hasX() const;

			




	
	
	
		
 
    unsigned numChannels() const;

			




	
	
	
		
 

			




	
	
	
		
 
    unsigned numSamples() const;

			




	
	
	
		
 
    const StreamChannel* channel(unsigned index) const;

			




	
	
	
		
 
    StreamChannel* channel(unsigned index);

			




	
	
	
		
 
    const ChannelInfoModel* infoModel() const;

			




	
	
	
		
 
    ChannelInfoModel* infoModel();

			




	
	
	
		
 

			




	
	
	
		
 
    /// Saves channel information

			




	
	
	
		
 
    void saveSettings(QSettings* settings) const;

			




	
	
	
		
 
    /// Load channel information

			




	
	
	
		
 
    void loadSettings(QSettings* settings);

			




	
	
	
		
 

			




	
	
	
		
 
protected:

			




	
	
	
		
 
    // implementations for `Sink`

			




	
	
	
		
 
    virtual void setNumChannels(unsigned nc, bool x);

			




	
	
	
		
 
    virtual void feedIn(const SamplePack& pack);

			




	
	
	
		
 

			




	
	
	
		
 
signals:

			




	
	
	
		
 
    void numChannelsChanged(unsigned value);

			




	
	
	
		
 
    void numSamplesChanged(unsigned value);

			




	
	
	
		
 
    void channelAdded(const StreamChannel* chan);

			




	
	
	
		
 
    void channelNameChanged(unsigned channel, QString name); // TODO: does it stay?

			




	
	
	
		
 
    void dataAdded(); ///< emitted when data added to channel man.

			




	
	
	
		
 

			




	
	
	
		
 
public slots:

			




	
	
	
		
 
    // TODO: these won't be public

			




	
	
	
		
 
    // void setNumChannels(unsigned number);

			




	
	
	
		
 
    /// Change number of samples (buffer size)

			




	
	
	
		
 
    void setNumSamples(unsigned value);

			




	
	
	
		
 

			




	
	
	
		
 
    /// Change X axis style

			




	
	
	
		
 
    /// @note Ignored when X is provided by source (hasX == true)

			




	
	
	
		
 
    void setXAxis(bool asIndex, double min, double max);

			




	
	
	
		
 

			




	
	
	
		
 
    /// When paused data feed is ignored

			




	
	
	
		
 
    void pause(bool paused);

			




	
	
	
		
 

			




	
	
	
		
 
    /// Clears buffer data (fills with 0)

			




	
	
	
		
 
    void clear();

			




	
	
	
		
 

			




	
	
	
		
 
private:

			




	
	
	
		
 
    unsigned _numSamples;

			




	
	
	
		
 
    bool _paused;

			




	
	
	
		
 

			




	
	
	
		
 
    bool _hasx;

			




	
	
	
		
 
    XFrameBuffer* xData;

			




	
	
	
		
 
    QList<StreamChannel*> channels;

			




	
	
	
		
 

			




	
	
	
		
 
    ChannelInfoModel _infoModel;

			




	
	
	
		
 

			




	
	
	
		
 
    bool xAsIndex;

			




	
	
	
		
 
    double xMin, xMax;

			




	
	
	
		
 

			




	
	
	
		
 
    /**

			




	
	
	
		
 
     * Applies gain and offset to given pack.

			




	
	
	
		
 
     *

			




	
	
	
		
 
     * Caller is responsible for deleting returned `SamplePack`.

			




	
	
	
		
 
     *

			




	
	
	
		
 
     * @note Should be called only when gain or offset is enabled. Guard with

			




	
	
	
		
 
     * `ChannelInfoModel::gainOrOffsetEn()`.

			




	
	
	
		
 
     *

			




	
	
	
		
 
     * @param pack input data

			




	
	
	
		
 
     * @return modified data

			




	
	
	
		
 
     */

			




	
	
	
		
 
    const SamplePack* applyGainOffset(const SamplePack& pack) const;

			




	
	
	
		
 

			




	
	
	
		
 
    /// Returns a new virtual X buffer for settings

			




	
	
	
		
 
    XFrameBuffer* makeXBuffer() const;

			




	
	
	
		
 
};

			




	
	
	
		
 

			




	
	
	
		
 

			




	
	
	
		
 
#endif // STREAM_H

			




        

    


    
    

    

        

                

                    tests/test.cpp
                

                

                  
                      
                        

                      ➞

                      
                        
                  

                  
                      
                  
                      
                  
                      
                  
                      
                  
                  
                

                

                    Show inline comments
                    
                

        

        

            



	
	
		
 
@@ -32,352 +32,360 @@

			




	
	
	
		
 
TEST_CASE("samplepack with no X", "[memory]")

			




	
	
	
		
 
{

			




	
	
	
		
 
    SamplePack pack(100, 3, false);

			




	
	
	
		
 

			




	
	
	
		
 
    REQUIRE_FALSE(pack.hasX());

			




	
	
	
		
 
    REQUIRE(pack.numChannels() == 3);

			




	
	
	
		
 
    REQUIRE(pack.numSamples() == 100);

			




	
	
	
		
 

			




	
	
	
		
 
    double* chan0 = pack.data(0);

			




	
	
	
		
 
    double* chan1 = pack.data(1);

			




	
	
	
		
 
    double* chan2 = pack.data(2);

			




	
	
	
		
 

			




	
	
	
		
 
    REQUIRE(chan0 == chan1 - 100);

			




	
	
	
		
 
    REQUIRE(chan1 == chan2 - 100);

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
TEST_CASE("samplepack with X", "[memory]")

			




	
	
	
		
 
{

			




	
	
	
		
 
    SamplePack pack(100, 3, true);

			




	
	
	
		
 

			




	
	
	
		
 
    REQUIRE(pack.hasX());

			




	
	
	
		
 
    REQUIRE(pack.numChannels() == 3);

			




	
	
	
		
 
    REQUIRE(pack.numSamples() == 100);

			




	
	
	
		
 
    REQUIRE(pack.xData() != nullptr);

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
TEST_CASE("samplepack copy", "[memory]")

			




	
	
	
		
 
{

			




	
	
	
		
 
    SamplePack pack(10, 3, true);

			




	
	
	
		
 

			




	
	
	
		
 
    // fill test data

			




	
	
	
		
 
    for (int i = 0; i < 10; i++)

			




	
	
	
		
 
    {

			




	
	
	
		
 
        pack.xData()[i] = i;

			




	
	
	
		
 
        pack.data(0)[i] = i+5;

			




	
	
	
		
 
        pack.data(1)[i] = i*2;

			




	
	
	
		
 
        pack.data(2)[i] = i*3;

			




	
	
	
		
 
    }

			




	
	
	
		
 

			




	
	
	
		
 
    SamplePack other = pack;

			




	
	
	
		
 
    // compare

			




	
	
	
		
 
    for (int i = 0; i < 10; i++)

			




	
	
	
		
 
    {

			




	
	
	
		
 
        REQUIRE(other.xData()[i] == i);

			




	
	
	
		
 
        REQUIRE(other.data(0)[i] == i+5);

			




	
	
	
		
 
        REQUIRE(other.data(1)[i] == i*2);

			




	
	
	
		
 
        REQUIRE(other.data(2)[i] == i*3);

			




	
	
	
		
 
    }

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
TEST_CASE("sink", "[memory, stream]")

			




	
	
	
		
 
{

			




	
	
	
		
 
    TestSink sink;

			




	
	
	
		
 
    SamplePack pack(100, 3, false);

			




	
	
	
		
 

			




	
	
	
		
 
    sink.setNumChannels(3, false);

			




	
	
	
		
 
    REQUIRE(sink.numChannels() == 3);

			




	
	
	
		
 

			




	
	
	
		
 
    sink.feedIn(pack);

			




	
	
	
		
 
    REQUIRE(sink.totalFed == 100);

			




	
	
	
		
 
    sink.feedIn(pack);

			




	
	
	
		
 
    REQUIRE(sink.totalFed == 200);

			




	
	
	
		
 

			




	
	
	
		
 
    TestSink follower;

			




	
	
	
		
 

			




	
	
	
		
 
    sink.connectFollower(&follower);

			




	
	
	
		
 
    REQUIRE(follower.numChannels() == 3);

			




	
	
	
		
 
    REQUIRE(follower.hasX() == false);

			




	
	
	
		
 

			




	
	
	
		
 
    sink.feedIn(pack);

			




	
	
	
		
 
    REQUIRE(sink.totalFed == 300);

			




	
	
	
		
 
    REQUIRE(follower.totalFed == 100);

			




	
	
	
		
 

			




	
	
	
		
 
    sink.setNumChannels(2, true);

			




	
	
	
		
 
    REQUIRE(follower.numChannels() == 2);

			




	
	
	
		
 
    REQUIRE(follower.hasX() == true);

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
TEST_CASE("sink must be created unconnected", "[memory, stream]")

			




	
	
	
		
 
{

			




	
	
	
		
 
    TestSink sink;

			




	
	
	
		
 
    REQUIRE(sink.connectedSource() == NULL);

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
TEST_CASE("source", "[memory, stream]")

			




	
	
	
		
 
{

			




	
	
	
		
 
    TestSink sink;

			




	
	
	
		
 

			




	
	
	
		
 
    TestSource source(3, false);

			




	
	
	
		
 

			




	
	
	
		
 
    REQUIRE(source.numChannels() == 3);

			




	
	
	
		
 
    REQUIRE(source.hasX() == false);

			




	
	
	
		
 

			




	
	
	
		
 
    source.connectSink(&sink);

			




	
	
	
		
 
    REQUIRE(sink.numChannels() == 3);

			




	
	
	
		
 
    REQUIRE(sink.hasX() == false);

			




	
	
	
		
 

			




	
	
	
		
 
    source._setNumChannels(5, true);

			




	
	
	
		
 
    REQUIRE(sink.numChannels() == 5);

			




	
	
	
		
 
    REQUIRE(sink.hasX() == true);

			




	
	
	
		
 

			




	
	
	
		
 
    SamplePack pack(100, 5, true);

			




	
	
	
		
 
    source._feed(pack);

			




	
	
	
		
 
    REQUIRE(sink.totalFed == 100);

			




	
	
	
		
 

			




	
	
	
		
 
    source.disconnect(&sink);

			




	
	
	
		
 
    source._feed(pack);

			




	
	
	
		
 
    REQUIRE(sink.totalFed == 100);

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
TEST_CASE("source must set/unset sink 'source'", "[memory, stream]")

			




	
	
	
		
 
{

			




	
	
	
		
 
    TestSink sink;

			




	
	
	
		
 
    TestSource source(3, false);

			




	
	
	
		
 

			




	
	
	
		
 
    source.connectSink(&sink);

			




	
	
	
		
 
    REQUIRE(sink.connectedSource() == &source);

			




	
	
	
		
 

			




	
	
	
		
 
    source.disconnect(&sink);

			




	
	
	
		
 
    REQUIRE(sink.connectedSource() == NULL);

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
TEST_CASE("source disconnect all sinks", "[memory, stream]")

			




	
	
	
		
 
{

			




	
	
	
		
 
    TestSink sinks[3];

			




	
	
	
		
 
    TestSource source(3, false);

			




	
	
	
		
 

			




	
	
	
		
 
    // connect sinks

			




	
	
	
		
 
    for (int i = 0; i < 3; i++)

			




	
	
	
		
 
    {

			




	
	
	
		
 
        source.connectSink(&sinks[i]);

			




	
	
	
		
 
    }

			




	
	
	
		
 

			




	
	
	
		
 
    source.disconnectSinks();

			




	
	
	
		
 
    for (int i = 0; i < 3; i++)

			




	
	
	
		
 
    {

			




	
	
	
		
 
        REQUIRE(sinks[i].connectedSource() == NULL);

			




	
	
	
		
 
    }

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
TEST_CASE("IndexBuffer", "[memory, buffer]")

			




	
	
	
		
 
{

			




	
	
	
		
 
    IndexBuffer buf(10);

			




	
	
	
		
 

			




	
	
	
		
 
    REQUIRE(buf.size() == 10);

			




	
	
	
		
 
    for (unsigned i = 0; i < 10; i++)

			




	
	
	
		
 
    {

			




	
	
	
		
 
        REQUIRE(buf.sample(i) == i);

			




	
	
	
		
 
    }

			




	
	
	
		
 
    auto l = buf.limits();

			




	
	
	
		
 
    REQUIRE(l.start == 0);

			




	
	
	
		
 
    REQUIRE(l.end == 9);

			




	
	
	
		
 

			




	
	
	
		
 
    buf.resize(20);

			




	
	
	
		
 
    REQUIRE(buf.size() == 20);

			




	
	
	
		
 
    REQUIRE(buf.sample(15) == 15);

			




	
	
	
		
 
    l = buf.limits();

			




	
	
	
		
 
    REQUIRE(l.start == 0);

			




	
	
	
		
 
    REQUIRE(l.end == 19);

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
TEST_CASE("LinIndexBuffer", "[memory, buffer]")

			




	
	
	
		
 
{

			




	
	
	
		
 
    LinIndexBuffer buf(10, 0., 3.0);

			




	
	
	
		
 

			




	
	
	
		
 
    REQUIRE(buf.size() == 10);

			




	
	
	
		
 
    REQUIRE(buf.sample(0) == 0.);

			




	
	
	
		
 
    REQUIRE(buf.sample(9) == 3.0);

			




	
	
	
		
 
    REQUIRE(buf.sample(4) == Approx(1+1/3.));

			




	
	
	
		
 

			




	
	
	
		
 
    auto l = buf.limits();

			




	
	
	
		
 
    REQUIRE(l.start == 0.);

			




	
	
	
		
 
    REQUIRE(l.end == 3.);

			




	
	
	
		
 

			




	
	
	
		
 
    buf.resize(20);

			




	
	
	
		
 
    REQUIRE(buf.size() == 20);

			




	
	
	
		
 
    REQUIRE(buf.sample(0) == 0.);

			




	
	
	
		
 
    REQUIRE(buf.sample(9) == Approx(9.*3./19.));

			




	
	
	
		
 
    REQUIRE(buf.sample(4) == Approx(4.*3./19.));

			




	
	
	
		
 
    REQUIRE(buf.sample(19) == 3.0);

			




	
	
	
		
 

			




	
	
	
		
 
    l = buf.limits();

			




	
	
	
		
 
    REQUIRE(l.start == 0.);

			




	
	
	
		
 
    REQUIRE(l.end == 3.0);

			




	
	
	
		
 

			




	
	
	
		
 
    buf.setLimits({-5., 5.});

			




	
	
	
		
 
    l = buf.limits();

			




	
	
	
		
 
    REQUIRE(l.start == -5.0);

			




	
	
	
		
 
    REQUIRE(l.end == 5.0);

			




	
	
	
		
 

			




	
	
	
		
 
    REQUIRE(buf.sample(0) == -5.0);

			




	
	
	
		
 
    REQUIRE(buf.sample(19) == 5.0);

			




	
	
	
		
 

			




	
	
	
		
 
    buf.resize(10);

			




	
	
	
		
 
    buf.setLimits({0., 3.});

			




	
	
	
		
 
    REQUIRE(buf.findIndex(0.01) == 0);

			




	
	
	
		
 
    REQUIRE(buf.findIndex(1.51) == 4);

			




	
	
	
		
 
    REQUIRE(buf.findIndex(2.99) == 8);

			




	
	
	
		
 
    REQUIRE(buf.findIndex(3.01) == XFrameBuffer::OUT_OF_RANGE);

			




	
	
	
		
 
    REQUIRE(buf.findIndex(-0.01) == XFrameBuffer::OUT_OF_RANGE);

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
TEST_CASE("RingBuffer sizing", "[memory, buffer]")

			




	
	
	
		
 
{

			




	
	
	
		
 
    RingBuffer buf(10);

			




	
	
	
		
 

			




	
	
	
		
 
    REQUIRE(buf.size() == 10);

			




	
	
	
		
 

			




	
	
	
		
 
    buf.resize(5);

			




	
	
	
		
 
    REQUIRE(buf.size() == 5);

			




	
	
	
		
 

			




	
	
	
		
 
    buf.resize(15);

			




	
	
	
		
 
    REQUIRE(buf.size() == 15);

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
TEST_CASE("RingBuffer initial values should be 0", "[memory, buffer]")

			




	
	
	
		
 
{

			




	
	
	
		
 
    RingBuffer buf(10);

			




	
	
	
		
 

			




	
	
	
		
 
    for (unsigned i = 0; i < 10; i++)

			




	
	
	
		
 
    {

			




	
	
	
		
 
        REQUIRE(buf.sample(i) == 0.);

			




	
	
	
		
 
    }

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
TEST_CASE("RingBuffer data access", "[memory, buffer]")

			




	
	
	
		
 
{

			




	
	
	
		
 
    RingBuffer buf(10);

			




	
	
	
		
 
    double values[10] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};

			




	
	
	
		
 

			




	
	
	
		
 
    buf.addSamples(values, 10);

			




	
	
	
		
 

			




	
	
	
		
 
    REQUIRE(buf.size() == 10);

			




	
	
	
		
 
    for (unsigned i = 0; i < 10; i++)

			




	
	
	
		
 
    {

			




	
	
	
		
 
        REQUIRE(buf.sample(i) == values[i]);

			




	
	
	
		
 
    }

			




	
	
	
		
 

			




	
	
	
		
 
    buf.addSamples(values, 5);

			




	
	
	
		
 

			




	
	
	
		
 
    REQUIRE(buf.size() == 10);

			




	
	
	
		
 
    for (unsigned i = 0; i < 5; i++)

			




	
	
	
		
 
    {

			




	
	
	
		
 
        REQUIRE(buf.sample(i) == values[i+5]);

			




	
	
	
		
 
    }

			




	
	
	
		
 
    for (unsigned i = 5; i < 10; i++)

			




	
	
	
		
 
    {

			




	
	
	
		
 
        REQUIRE(buf.sample(i) == values[i-5]);

			




	
	
	
		
 
    }

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
TEST_CASE("making RingBuffer bigger should keep end values", "[memory, buffer]")

			




	
	
	
		
 
{

			




	
	
	
		
 
    RingBuffer buf(5);

			




	
	
	
		
 
    double values[10] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};

			




	
	
	
		
 

			




	
	
	
		
 
    buf.addSamples(values, 5);

			




	
	
	
		
 
    buf.resize(10);

			




	
	
	
		
 

			




	
	
	
		
 
    REQUIRE(buf.size() == 10);

			




	
	
	
		
 
    for (unsigned i = 0; i < 5; i++)

			




	
	
	
		
 
    {

			




	
	
	
		
 
        REQUIRE(buf.sample(i) == 0);

			




	
	
	
		
 
    }

			




	
	
	
		
 
    for (unsigned i = 5; i < 10; i++)

			




	
	
	
		
 
    {

			




	
	
	
		
 
        REQUIRE(buf.sample(i) == values[i-5]);

			




	
	
	
		
 
    }

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
TEST_CASE("making RingBuffer smaller should keep end values", "[memory, buffer]")

			




	
	
	
		
 
{

			




	
	
	
		
 
    RingBuffer buf(10);

			




	
	
	
		
 
    double values[10] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};

			




	
	
	
		
 

			




	
	
	
		
 
    buf.addSamples(values, 10);

			




	
	
	
		
 
    buf.resize(5);

			




	
	
	
		
 

			




	
	
	
		
 
    REQUIRE(buf.size() == 5);

			




	
	
	
		
 
    for (unsigned i = 0; i < 5; i++)

			




	
	
	
		
 
    {

			




	
	
	
		
 
        REQUIRE(buf.sample(i) == values[i+5]);

			




	
	
	
		
 
    }

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
TEST_CASE("RingBuffer limits", "[memory, buffer]")

			




	
	
	
		
 
{

			




	
	
	
		
 
    RingBuffer buf(10);

			




	
	
	
		
 
    double values[10] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};

			




	
	
	
		
 

			




	
	
	
		
 
    auto lim = buf.limits();

			




	
	
	
		
 
    REQUIRE(lim.start == 0.);

			




	
	
	
		
 
    REQUIRE(lim.end == 0.);

			




	
	
	
		
 

			




	
	
	
		
 
    buf.addSamples(values, 10);

			




	
	
	
		
 
    lim = buf.limits();

			




	
	
	
		
 
    REQUIRE(lim.start == 1.);

			




	
	
	
		
 
    REQUIRE(lim.end == 10.);

			




	
	
	
		
 

			




	
	
	
		
 
    buf.addSamples(&values[9], 1);

			




	
	
	
		
 
    lim = buf.limits();

			




	
	
	
		
 
    REQUIRE(lim.start == 2.);

			




	
	
	
		
 
    REQUIRE(lim.end == 10.);

			




	
	
	
		
 

			




	
	
	
		
 
    buf.addSamples(values, 9);

			




	
	
	
		
 
    buf.addSamples(values, 1);

			




	
	
	
		
 
    lim = buf.limits();

			




	
	
	
		
 
    REQUIRE(lim.start == 1.);

			




	
	
	
		
 
    REQUIRE(lim.end == 9.);

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
TEST_CASE("RingBuffer clear", "[memory, buffer]")

			




	
	
	
		
 
{

			




	
	
	
		
 
    RingBuffer buf(10);

			




	
	
	
		
 
    double values[10] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};

			




	
	
	
		
 

			




	
	
	
		
 
    buf.addSamples(values, 10);

			




	
	
	
		
 
    buf.clear();

			




	
	
	
		
 

			




	
	
	
		
 
    REQUIRE(buf.size() == 10);

			




	
	
	
		
 
    for (unsigned i = 0; i < 10; i++)

			




	
	
	
		
 
    {

			




	
	
	
		
 
        REQUIRE(buf.sample(i) == 0.);

			




	
	
	
		
 
    }

			




	
	
	
		
 
    auto lim = buf.limits();

			




	
	
	
		
 
    REQUIRE(lim.start == 0.);

			




	
	
	
		
 
    REQUIRE(lim.end == 0.);

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
TEST_CASE("ReadOnlyBuffer", "[memory, buffer]")

			




	
	
	
		
 
{

			




	
	
	
		
 
    IndexBuffer source(10);

			




	
	
	
		
 

			




	
	
	
		
 
    ReadOnlyBuffer buf(&source);

			




	
	
	
		
 

			




	
	
	
		
 
    REQUIRE(buf.size() == 10);

			




	
	
	
		
 
    auto lim = buf.limits();

			




	
	
	
		
 
    REQUIRE(lim.start == 0.);

			




	
	
	
		
 
    REQUIRE(lim.end == 9.);

			




	
	
	
		
 
    for (unsigned i = 0; i < 10; i++)

			




	
	
	
		
 
    {

			




	
	
	
		
 
        REQUIRE(buf.sample(i) == i);

			




	
	
	
		
 
    }

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
TEST_CASE("ReadOnlyBuffer sliced constructor", "[memory, buffer]")

			




	
	
	
		
 
{

			




	
	
	
		
 
    IndexBuffer source(10);

			




	
	
	
		
 

			




	
	
	
		
 
    ReadOnlyBuffer buf(&source, 5, 4);

			




	
	
	
		
 

			




	
	
	
		
 
    REQUIRE(buf.size() == 4);

			




	
	
	
		
 
    auto lim = buf.limits();

			




	
	
	
		
 
    REQUIRE(lim.start == 5.);

			




	
	
	
		
 
    REQUIRE(lim.end == 8.);

			




	
	
	
		
 
    for (unsigned i = 0; i < 4; i++)

			




	
	
	
		
 
    {

			




	
	
	
		
 
        REQUIRE(buf.sample(i) == (i + 5));

			




	
	
	
		
 
    }

			




	
	
	
		
 
}

			




        

    


    
    

    

        

                

                    tests/test_stream.cpp
                

                

                  
                      
                        

                      ➞

                      
                        
                  

                  
                      
                  
                      
                  
                      
                  
                      
                  
                  
                

                

                    Show inline comments
                    
                

        

        

            



	
	
	
		
 
/*

			




	
	
	
		
 
  Copyright © 2018 Hasan Yavuz Özderya

			




	
	
	
		
 

			




	
	
	
		
 
  This file is part of serialplot.

			




	
	
	
		
 

			




	
	
	
		
 
  serialplot is free software: you can redistribute it and/or modify

			




	
	
	
		
 
  it under the terms of the GNU General Public License as published by

			




	
	
	
		
 
  the Free Software Foundation, either version 3 of the License, or

			




	
	
	
		
 
  (at your option) any later version.

			




	
	
	
		
 

			




	
	
	
		
 
  serialplot is distributed in the hope that it will be useful,

			




	
	
	
		
 
  but WITHOUT ANY WARRANTY; without even the implied warranty of

			




	
	
	
		
 
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

			




	
	
	
		
 
  GNU General Public License for more details.

			




	
	
	
		
 

			




	
	
	
		
 
  You should have received a copy of the GNU General Public License

			




	
	
	
		
 
  along with serialplot.  If not, see <http://www.gnu.org/licenses/>.

			




	
	
	
		
 
*/

			




	
	
	
		
 

			




	
	
	
		
 
#include "stream.h"

			




	
	
	
		
 

			




	
	
	
		
 
#include "catch.hpp"

			




	
	
	
		
 
#include "test_helpers.h"

			




	
	
	
		
 

			




	
	
	
		
 
TEST_CASE("construction of stream with default values", "[memory, stream]")

			




	
	
	
		
 
{

			




	
	
	
		
 
    // default values are an empty stream with no channels

			




	
	
	
		
 
    Stream s;

			




	
	
	
		
 

			




	
	
	
		
 
    REQUIRE(s.numChannels() == 0);

			




	
	
	
		
 
    REQUIRE(s.numChannels() == 1);

			




	
	
	
		
 
    REQUIRE(!s.hasX());

			




	
	
	
		
 
    REQUIRE(s.numSamples() == 0);

			




	
	
	
		
 
    REQUIRE(s.numSamples() == 2);

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
TEST_CASE("construction of stream with parameters", "[memory, stream]")

			




	
	
	
		
 
{

			




	
	
	
		
 
    Stream s(4, true, 100);

			




	
	
	
		
 
    Stream s(4, false, 100);

			




	
	
	
		
 

			




	
	
	
		
 
    REQUIRE(s.numChannels() == 4);

			




	
	
	
		
 
    REQUIRE(s.hasX());

			




	
	
	
		
 
    REQUIRE(!s.hasX());

			




	
	
	
		
 
    REQUIRE(s.numSamples() == 100);

			




	
	
	
		
 

			




	
	
	
		
 
    for (unsigned i = 0; i < 4; i++)

			




	
	
	
		
 
    {

			




	
	
	
		
 
        const StreamChannel* c = s.channel(i);

			




	
	
	
		
 
        REQUIRE(c != NULL);

			




	
	
	
		
 
        REQUIRE(c->index() == i);

			




	
	
	
		
 
    }

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
TEST_CASE("changing stream number of channels via sink", "[memory, stream, sink]")

			




	
	
	
		
 
{

			




	
	
	
		
 
    Stream s;

			




	
	
	
		
 
    TestSource so(3, false);

			




	
	
	
		
 
    so.connectSink(&s);

			




	
	
	
		
 

			




	
	
	
		
 
    // nc=3, x= false

			




	
	
	
		
 
    REQUIRE(s.numChannels() == 3);

			




	
	
	
		
 
    REQUIRE(!s.hasX());

			




	
	
	
		
 
    for (unsigned i = 0; i < 3; i++)

			




	
	
	
		
 
    {

			




	
	
	
		
 
        const StreamChannel* c = s.channel(i);

			




	
	
	
		
 
        REQUIRE(c != NULL);

			




	
	
	
		
 
        REQUIRE(c->index() == i);

			




	
	
	
		
 
    }

			




	
	
	
		
 

			




	
	
	
		
 
// TODO: enable test when `Stream` supports X channel

			




	
	
	
		
 
#if 0

			




	
	
	
		
 
    // increase nc value, add X

			




	
	
	
		
 
    so._setNumChannels(5, true);

			




	
	
	
		
 

			




	
	
	
		
 
    REQUIRE(s.numChannels() == 5);

			




	
	
	
		
 
    REQUIRE(s.hasX());

			




	
	
	
		
 

			




	
	
	
		
 
    for (unsigned i = 0; i < 5; i++)

			




	
	
	
		
 
    {

			




	
	
	
		
 
        const StreamChannel* c = s.channel(i);

			




	
	
	
		
 
        REQUIRE(c != NULL);

			




	
	
	
		
 
        REQUIRE(c->index() == i);

			




	
	
	
		
 
    }

			




	
	
	
		
 
#endif

			




	
	
	
		
 

			




	
	
	
		
 
    // reduce nc value, remove X

			




	
	
	
		
 
    so._setNumChannels(1, false);

			




	
	
	
		
 

			




	
	
	
		
 
    REQUIRE(s.numChannels() == 1);

			




	
	
	
		
 
    REQUIRE(!s.hasX());

			




	
	
	
		
 

			




	
	
	
		
 
    for (unsigned i = 0; i < 1; i++)

			




	
	
	
		
 
    {

			




	
	
	
		
 
        const StreamChannel* c = s.channel(i);

			




	
	
	
		
 
        REQUIRE(c != NULL);

			




	
	
	
		
 
        REQUIRE(c->index() == i);

			




	
	
	
		
 
    }

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
TEST_CASE("adding data to a stream with no X", "[memory, stream, data, sink]")

			




	
	
	
		
 
{

			




	
	
	
		
 
    Stream s(3, false, 10);

			




	
	
	
		
 

			




	
	
	
		
 
    // prepare data

			




	
	
	
		
 
    SamplePack pack(5, 3, false);

			




	
	
	
		
 
    for (unsigned ci = 0; ci < 3; ci++)

			




	
	
	
		
 
    {

			




	
	
	
		
 
        for (unsigned i = 0; i < 5; i++)

			




	
	
	
		
 
        {

			




	
	
	
		
 
            pack.data(ci)[i] = i;

			




	
	
	
		
 
        }

			




	
	
	
		
 
    }

			




	
	
	
		
 

			




	
	
	
		
 
    TestSource so(3, false);

			




	
	
	
		
 
    so.connectSink(&s);

			




	
	
	
		
 

			




	
	
	
		
 
    // test

			




	
	
	
		
 
    so._feed(pack);

			




	
	
	
		
 

			




	
	
	
		
 
    for (unsigned ci = 0; ci < 3; ci++)

			




	
	
	
		
 
    {

			




	
	
	
		
 
        const StreamChannel* c = s.channel(ci);

			




	
	
	
		
 
        const FrameBuffer* y = c->yData();

			




	
	
	
		
 

			




	
	
	
		
 
        for (unsigned i = 0; i < 5; i++)

			




	
	
	
		
 
        {

			




	
	
	
		
 
            REQUIRE(y->sample(i) == 0);

			




	
	
	
		
 
        }

			




	
	
	
		
 
        for (unsigned i = 5; i < 10; i++)

			




	
	
	
		
 
        {

			




	
	
	
		
 
            REQUIRE(y->sample(i) == i-5);

			




	
	
	
		
 
        }

			




	
	
	
		
 
    }

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
// TODO: enable test when `Stream` supports X channel

			




	
	
	
		
 
#if 0

			




	
	
	
		
 
TEST_CASE("adding data to a stream with X", "[memory, stream, data, sink]")

			




	
	
	
		
 
{

			




	
	
	
		
 
    Stream s(3, true, 10);

			




	
	
	
		
 
    Stream s(3, false, 10);

			




	
	
	
		
 

			




	
	
	
		
 
    // prepare data

			




	
	
	
		
 
    SamplePack pack(5, 3, true);

			




	
	
	
		
 
    for (unsigned ci = 0; ci < 3; ci++)

			




	
	
	
		
 
    {

			




	
	
	
		
 
        for (unsigned i = 0; i < 5; i++)

			




	
	
	
		
 
        {

			




	
	
	
		
 
            pack.data(ci)[i] = i;

			




	
	
	
		
 
        }

			




	
	
	
		
 
    }

			




	
	
	
		
 
    // x data

			




	
	
	
		
 
    for (unsigned i = 0; i < 5; i++)

			




	
	
	
		
 
    {

			




	
	
	
		
 
        pack.xData()[i] = i+10;

			




	
	
	
		
 
    }

			




	
	
	
		
 

			




	
	
	
		
 
    TestSource so(3, true);

			




	
	
	
		
 
    so.connectSink(&s);

			




	
	
	
		
 
    REQUIRE_THROWS(so.connectSink(&s));

			




	
	
	
		
 

			




	
	
	
		
 
    // test

			




	
	
	
		
 
    so._feed(pack);

			




	
	
	
		
 

			




	
	
	
		
 
    for (unsigned ci = 0; ci < 3; ci++)

			




	
	
	
		
 
    {

			




	
	
	
		
 
        const StreamChannel* c = s.channel(ci);

			




	
	
	
		
 
        const FrameBuffer* y = c->yData();

			




	
	
	
		
 

			




	
	
	
		
 
        for (unsigned i = 0; i < 5; i++)

			




	
	
	
		
 
        {

			




	
	
	
		
 
            REQUIRE(y->sample(i) == 0);

			




	
	
	
		
 
        }

			




	
	
	
		
 
        for (unsigned i = 5; i < 10; i++)

			




	
	
	
		
 
        {

			




	
	
	
		
 
            REQUIRE(y->sample(i) == i-5);

			




	
	
	
		
 
        }

			




	
	
	
		
 
    }

			




	
	
	
		
 

			




	
	
	
		
 
    // check x

			




	
	
	
		
 
    const FrameBuffer* x = s.channel(0)->xData();

			




	
	
	
		
 
    for (unsigned i = 0; i < 5; i++)

			




	
	
	
		
 
    {

			




	
	
	
		
 
        REQUIRE(x->sample(i) == 0);

			




	
	
	
		
 
    }

			




	
	
	
		
 
    for (unsigned i = 5; i < 10; i++)

			




	
	
	
		
 
    {

			




	
	
	
		
 
        REQUIRE(x->sample(i) == (i-5)+10);

			




	
	
	
		
 
    }

			




	
	
	
		
 
}

			




	
	
	
		
 
#endif

			




	
	
	
		
 

			




	
	
	
		
 
TEST_CASE("paused stream shouldn't store data", "[memory, stream, pause]")

			




	
	
	
		
 
{

			




	
	
	
		
 
    Stream s(3, false, 10);

			




	
	
	
		
 

			




	
	
	
		
 
    // prepare data

			




	
	
	
		
 
    SamplePack pack(5, 3, false);

			




	
	
	
		
 
    for (unsigned ci = 0; ci < 3; ci++)

			




	
	
	
		
 
    {

			




	
	
	
		
 
        for (unsigned i = 0; i < 5; i++)

			




	
	
	
		
 
        {

			




	
	
	
		
 
            pack.data(ci)[i] = i;

			




	
	
	
		
 
        }

			




	
	
	
		
 
    }

			




	
	
	
		
 

			




	
	
	
		
 
    TestSource so(3, false);

			




	
	
	
		
 
    so.connectSink(&s);

			




	
	
	
		
 

			




	
	
	
		
 
    // test

			




	
	
	
		
 
    s.pause(true);

			




	
	
	
		
 
    so._feed(pack);

			




	
	
	
		
 

			




	
	
	
		
 
    for (unsigned ci = 0; ci < 3; ci++)

			




	
	
	
		
 
    {

			




	
	
	
		
 
        const StreamChannel* c = s.channel(ci);

			




	
	
	
		
 
        const FrameBuffer* y = c->yData();

			




	
	
	
		
 

			




	
	
	
		
 
        for (unsigned i = 0; i < 10; i++)

			




	
	
	
		
 
        {

			




	
	
	
		
 
            REQUIRE(y->sample(i) == 0);

			




	
	
	
		
 
        }

			




	
	
	
		
 
    }

			




	
	
	
		
 
}

			




	
	
	
		
 

			




	
	
	
		
 
TEST_CASE("clear stream data", "[memory, stream, pause]")

			




	
	
	
		
 
{

			




	
	
	
		
 
    Stream s(3, false, 10);

			




	
	
	
		
 

			




	
	
	
		
 
    // prepare data

			




	
	
	
		
 
    SamplePack pack(5, 3, false);

			




	
	
	
		
 
    for (unsigned ci = 0; ci < 3; ci++)

			




	
	
	
		
 
    {

			




	
	
	
		
 
        for (unsigned i = 0; i < 5; i++)

			




	
	
	
		
 
        {

			




	
	
	
		
 
            pack.data(ci)[i] = i;

			




	
	
	
		
 
        }

			




	
	
	
		
 
    }

			




	
	
	
		
 

			




	
	
	
		
 
    TestSource so(3, false);

			




	
	
	
		
 
    so.connectSink(&s);

			




	
	
	
		
 

			




	
	
	
		
 
    // test

			




	
	
	
		
 
    so._feed(pack);

			




	
	
	
		
 
    s.clear();

			




	
	
	
		
 

			




	
	
	
		
 
    for (unsigned ci = 0; ci < 3; ci++)

			




	
	
	
		
 
    {

			




	
	
	
		
 
        const StreamChannel* c = s.channel(ci);

			




	
	
	
		
 
        const FrameBuffer* y = c->yData();

			




	
	
	
		
 

			




	
	
	
		
 
        for (unsigned i = 0; i < 10; i++)

			




	
	
	
		
 
        {

			




	
	
	
		
 
            REQUIRE(y->sample(i) == 0);

			




	
	
	
		
 
        }

			




	
	
	
		
 
    }

			




	
	
	
		
 
}

			




        

    



    


    



    



      

      





    
    0 comments (0 inline, 0 general)
    





    


  

  







  


    




    








    
        Server instance: zserverv-13856
    
    
        This site is powered by
            Kallithea,
        which is
        © 2010–2021 by various authors & licensed under GPLv3.
            – Support