mirror of
https://gitlab.kitware.com/vtk/vtk-m
synced 2024-09-16 17:22:55 +00:00
178 lines
7.1 KiB
C++
178 lines
7.1 KiB
C++
//============================================================================
|
|
// Copyright (c) Kitware, Inc.
|
|
// All rights reserved.
|
|
// See LICENSE.txt for details.
|
|
//
|
|
// This software is distributed WITHOUT ANY WARRANTY; without even
|
|
// the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
|
|
// PURPOSE. See the above copyright notice for more information.
|
|
//============================================================================
|
|
|
|
#include <vtkm/cont/testing/Testing.h>
|
|
#include <vtkm/io/PixelTypes.h>
|
|
|
|
#include <string>
|
|
|
|
using namespace vtkm::io;
|
|
|
|
template <typename PixelType>
|
|
void TestPixelTypeOperations(const vtkm::UInt16& numPixels = 10)
|
|
{
|
|
using ValType = typename PixelType::ComponentType;
|
|
const ValType numBytes = static_cast<ValType>(PixelType::NUM_BYTES);
|
|
const ValType numChannels = static_cast<ValType>(PixelType::NUM_CHANNELS);
|
|
|
|
// Fill in the imageData through FillPixelData
|
|
std::vector<unsigned char> imageData(numPixels * numBytes * numChannels);
|
|
std::vector<PixelType> pixelVector(numPixels);
|
|
for (ValType i = 0; i < numPixels; i++)
|
|
{
|
|
ValType pixelVal = 0;
|
|
for (ValType j = 0, shift = numBytes - 1; j < numBytes; shift--, j++)
|
|
{
|
|
pixelVal += (i + j) << (shift * 8);
|
|
}
|
|
|
|
PixelType pixel(pixelVal);
|
|
pixelVector[i] = pixel;
|
|
pixel.FillImageAtIndexWithPixel(imageData.data(), i);
|
|
}
|
|
|
|
// Test that the imageData values were set correctly
|
|
VTKM_TEST_ASSERT(static_cast<vtkm::Id>(imageData.size()) == numPixels * numChannels * numBytes,
|
|
"Wrong number of elements");
|
|
for (ValType j = 0; j < numBytes; j++)
|
|
{
|
|
for (ValType i = 0; i < numPixels; i++)
|
|
{
|
|
for (ValType k = numChannels * i; k < numChannels * i + numChannels; k++)
|
|
{
|
|
VTKM_TEST_ASSERT(imageData[k * numBytes + j] == i + j,
|
|
"Wrong value at index[" + std::to_string(k * numBytes + j) +
|
|
"]: " + std::to_string(imageData[k * numBytes + j]) +
|
|
" != " + std::to_string(i + j));
|
|
}
|
|
}
|
|
}
|
|
|
|
// Test that a pixel can be retreived from the filled out data vector
|
|
for (vtkm::Id i = 0; i < numPixels; i++)
|
|
{
|
|
VTKM_TEST_ASSERT(pixelVector[static_cast<typename std::vector<PixelType>::size_type>(i)] ==
|
|
PixelType(imageData.data(), i),
|
|
"Incorrect pixel value");
|
|
}
|
|
}
|
|
|
|
void TestDifferentPixelTypes()
|
|
{
|
|
VTKM_LOG_S(vtkm::cont::LogLevel::Info, "Testing 8 bit RGB");
|
|
TestPixelTypeOperations<RGBPixel_8>();
|
|
|
|
VTKM_LOG_S(vtkm::cont::LogLevel::Info, "Testing 8 bit Grey");
|
|
TestPixelTypeOperations<GreyPixel_8>();
|
|
|
|
VTKM_LOG_S(vtkm::cont::LogLevel::Info, "Testing 16 bit RGB");
|
|
TestPixelTypeOperations<RGBPixel_16>();
|
|
|
|
VTKM_LOG_S(vtkm::cont::LogLevel::Info, "Testing 16 bit Grey");
|
|
TestPixelTypeOperations<GreyPixel_16>();
|
|
}
|
|
|
|
void TestGreyPixelConstructors()
|
|
{
|
|
std::vector<unsigned char> initData{ 1, 2 };
|
|
|
|
auto pixel_1 = GreyPixel_8(1);
|
|
auto pixel_2 = GreyPixel_8(1);
|
|
auto pixel_3 = GreyPixel_8(2);
|
|
auto pixel_4 = GreyPixel_8(initData.data(), 0);
|
|
auto pixel_5 = GreyPixel_8(initData.data(), 1);
|
|
auto pixel_6 = GreyPixel_16(initData.data(), 0);
|
|
|
|
float color = 10.0f / GreyPixel_16::MAX_COLOR_VALUE;
|
|
auto pixel_7 = GreyPixel_16({ color, color, color, 5 });
|
|
|
|
VTKM_TEST_ASSERT(vtkm::UInt16(1) == pixel_1[0], "Type mis-match");
|
|
VTKM_TEST_ASSERT(vtkm::FloatDefault(0) == pixel_1.Diff(pixel_2), "Incorrect Diff");
|
|
VTKM_TEST_ASSERT(vtkm::FloatDefault(1) == pixel_1.Diff(pixel_3), "Incorrect Diff");
|
|
VTKM_TEST_ASSERT(vtkm::Vec4f_32(1.0f / 255, 1.0f / 255, 1.0f / 255, 1) == pixel_1.ToVec4f(),
|
|
"Incorrect Conversion");
|
|
VTKM_TEST_ASSERT(vtkm::Vec<vtkm::UInt8, 1>(1) == pixel_4, "Bad 1st value 8 bit construct");
|
|
VTKM_TEST_ASSERT(vtkm::Vec<vtkm::UInt8, 1>(2) == pixel_5, "Bad 2nd value 8 bit construct");
|
|
VTKM_TEST_ASSERT(vtkm::Vec<vtkm::UInt16, 1>(258) == pixel_6, "Bad 16 bit construct");
|
|
VTKM_TEST_ASSERT(vtkm::Vec4f_32(258.0f / 65535, 258.0f / 65535, 258.0f / 65535, 1) ==
|
|
pixel_6.ToVec4f(),
|
|
"Incorrect Conversion");
|
|
VTKM_TEST_ASSERT(vtkm::Vec<vtkm::UInt16, 1>(10) == pixel_7, "Bad Vec4f_32 construction");
|
|
|
|
VTKM_TEST_ASSERT(GreyPixel<16>::GetBitDepth() == 16, "Bad BitDepth");
|
|
VTKM_TEST_ASSERT(GreyPixel<16>::BIT_DEPTH == 16, "Bad BitDepth");
|
|
VTKM_TEST_ASSERT(GreyPixel<16>::NUM_BYTES == 2, "Bad NumBytes");
|
|
VTKM_TEST_ASSERT(GreyPixel<16>::MAX_COLOR_VALUE == 65535, "Bad NumBytes");
|
|
VTKM_TEST_ASSERT(GreyPixel<16>::NUM_CHANNELS == 1, "Bad NumChannels");
|
|
VTKM_TEST_ASSERT(GreyPixel<16>::BYTES_PER_PIXEL == 2, "Wrong Pixel Byte distance");
|
|
|
|
// Shouldn't compile
|
|
// auto pixel_4 = RGBPixel_8(1, 1, 1);
|
|
// pixel_1.Diff(pixel_4);
|
|
}
|
|
|
|
void TestRGBPixelConstructors()
|
|
{
|
|
std::vector<unsigned char> initData{ 1, 2, 3, 4, 5, 6 };
|
|
|
|
auto pixel_1 = RGBPixel_8(1, 1, 1);
|
|
auto pixel_2 = RGBPixel_8(1, 1, 1);
|
|
auto pixel_3 = RGBPixel_8(1);
|
|
auto pixel_4 = RGBPixel_8(2, 2, 2);
|
|
auto pixel_5 = RGBPixel_8(initData.data(), 0);
|
|
auto pixel_6 = RGBPixel_8(initData.data(), 1);
|
|
auto pixel_7 = RGBPixel_16(initData.data(), 0);
|
|
|
|
float color = 10.0f / RGBPixel_16::MAX_COLOR_VALUE;
|
|
auto pixel_8 = RGBPixel_16({ color, color, color, 5 });
|
|
|
|
VTKM_TEST_ASSERT(vtkm::Vec3ui_8(1, 1, 1) == pixel_1, "Type mis-match");
|
|
VTKM_TEST_ASSERT(vtkm::FloatDefault(0) == pixel_1.Diff(pixel_2), "Incorrect Diff");
|
|
VTKM_TEST_ASSERT(vtkm::FloatDefault(0) == pixel_1.Diff(pixel_3), "Incorrect Diff");
|
|
VTKM_TEST_ASSERT(vtkm::FloatDefault(3) == pixel_1.Diff(pixel_4), "Incorrect Diff");
|
|
VTKM_TEST_ASSERT(vtkm::Vec4f_32(1.0f / 255, 1.0f / 255, 1.0f / 255, 1) == pixel_1.ToVec4f(),
|
|
"Incorrect Conversion");
|
|
VTKM_TEST_ASSERT(vtkm::Vec3ui_8(1, 2, 3) == pixel_5, "Bad 1st value 8 bit construct");
|
|
VTKM_TEST_ASSERT(vtkm::Vec3ui_8(4, 5, 6) == pixel_6, "Bad 2nd value 8 bit construct");
|
|
VTKM_TEST_ASSERT(vtkm::Vec3ui_16(258, 772, 1286) == pixel_7, "Bad 16 bit construct");
|
|
VTKM_TEST_ASSERT(vtkm::Vec4f_32(258.0f / 65535, 772.0f / 65535, 1286.0f / 65535, 1) ==
|
|
pixel_7.ToVec4f(),
|
|
"Incorrect Conversion");
|
|
VTKM_TEST_ASSERT(vtkm::Vec<vtkm::UInt16, 3>(10, 10, 10) == pixel_8, "Bad Vec4f_32 construction");
|
|
|
|
VTKM_TEST_ASSERT(RGBPixel<16>::GetBitDepth() == 16, "Bad BitDepth");
|
|
VTKM_TEST_ASSERT(RGBPixel<16>::BIT_DEPTH == 16, "Bad BitDepth");
|
|
VTKM_TEST_ASSERT(RGBPixel<16>::NUM_BYTES == 2, "Bad NumBytes");
|
|
VTKM_TEST_ASSERT(RGBPixel<16>::MAX_COLOR_VALUE == 65535, "Bad NumBytes");
|
|
VTKM_TEST_ASSERT(RGBPixel<16>::NUM_CHANNELS == 3, "Bad NumChannels");
|
|
VTKM_TEST_ASSERT(RGBPixel<16>::BYTES_PER_PIXEL == 6, "Wrong Pixel Byte distance");
|
|
|
|
// Shouldn't compile
|
|
// auto pixel_8 = GreyPixel_8(1);
|
|
// pixel_1.Diff(pixel_8);
|
|
}
|
|
|
|
void TestPixelTypes()
|
|
{
|
|
VTKM_LOG_S(vtkm::cont::LogLevel::Info, "Testing RGBPixel");
|
|
TestRGBPixelConstructors();
|
|
|
|
VTKM_LOG_S(vtkm::cont::LogLevel::Info, "Testing GreyPixel");
|
|
TestGreyPixelConstructors();
|
|
|
|
VTKM_LOG_S(vtkm::cont::LogLevel::Info, "Testing Pixel Types");
|
|
TestDifferentPixelTypes();
|
|
}
|
|
|
|
int UnitTestPixelTypes(int argc, char* argv[])
|
|
{
|
|
return vtkm::cont::testing::Testing::Run(TestPixelTypes, argc, argv);
|
|
}
|