Commit 1c347f48 authored by Vadim Pisarevsky's avatar Vadim Pisarevsky

removed obsolete tests

parent b9fa21d0
# ----------------------------------------------------------------------------
# CMake file for cvtest. See root CMakeLists.txt
#
# ----------------------------------------------------------------------------
project(opencv_test)
file(GLOB test_srcs "src/*.cpp")
source_group("Src" FILES ${test_srcs})
file(GLOB test_hdrs "src/*.h*")
source_group("Include" FILES ${test_hdrs})
include_directories("${CMAKE_SOURCE_DIR}/include/opencv"
"${CMAKE_SOURCE_DIR}/modules/core/include"
"${CMAKE_SOURCE_DIR}/modules/imgproc/include"
"${CMAKE_SOURCE_DIR}/modules/features2d/include"
"${CMAKE_SOURCE_DIR}/modules/flann/include"
"${CMAKE_SOURCE_DIR}/modules/calib3d/include"
"${CMAKE_SOURCE_DIR}/modules/highgui/include"
"${CMAKE_SOURCE_DIR}/modules/objdetect/include"
"${CMAKE_SOURCE_DIR}/modules/video/include"
"${CMAKE_SOURCE_DIR}/modules/legacy/include"
"${CMAKE_SOURCE_DIR}/modules/contrib/include"
"${CMAKE_CURRENT_SOURCE_DIR}/src"
"${CMAKE_CURRENT_BINARY_DIR}")
include_directories(../cxts)
set(the_target "opencv_test")
add_executable(${the_target} ${test_srcs} ${test_hdrs})
if(PCHSupport_FOUND)
set(pch_header ${CMAKE_SOURCE_DIR}/tests/cv/src/cvtest.h)
if(${CMAKE_GENERATOR} MATCHES "Visual*" OR ${CMAKE_GENERATOR} MATCHES "Xcode*")
if(${CMAKE_GENERATOR} MATCHES "Visual*")
set(${the_target}_pch "src/cvtest.cpp")
endif()
add_native_precompiled_header(${the_target} ${pch_header})
elseif(CMAKE_COMPILER_IS_GNUCXX AND ${CMAKE_GENERATOR} MATCHES ".*Makefiles")
add_precompiled_header(${the_target} ${pch_header})
endif()
endif()
# Additional target properties
set_target_properties(${the_target} PROPERTIES
DEBUG_POSTFIX "${OPENCV_DEBUG_POSTFIX}"
RUNTIME_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}/bin/"
)
add_dependencies(${the_target} opencv_ts opencv_core opencv_imgproc opencv_calib3d opencv_features2d opencv_objdetect opencv_video opencv_highgui opencv_legacy opencv_contrib)
# Add the required libraries for linking:
target_link_libraries(${the_target} ${OPENCV_LINKER_LIBS} opencv_ts opencv_core opencv_imgproc opencv_calib3d opencv_features2d opencv_objdetect opencv_video opencv_highgui opencv_legacy opencv_contrib)
enable_testing()
get_target_property(LOC ${the_target} LOCATION)
add_test(cvtest "${LOC}")
if(WIN32)
install(TARGETS ${the_target} RUNTIME DESTINATION bin COMPONENT main)
endif()
/*M///////////////////////////////////////////////////////////////////////////////////////
//
// IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
//
// By downloading, copying, installing or using the software you agree to this license.
// If you do not agree to this license, do not download, install,
// copy or use the software.
//
//
// Intel License Agreement
// For Open Source Computer Vision Library
//
// Copyright (C) 2000, Intel Corporation, all rights reserved.
// Third party copyrights are property of their respective owners.
//
// Redistribution and use in source and binary forms, with or without modification,
// are permitted provided that the following conditions are met:
//
// * Redistribution's of source code must retain the above copyright notice,
// this list of conditions and the following disclaimer.
//
// * Redistribution's in binary form must reproduce the above copyright notice,
// this list of conditions and the following disclaimer in the documentation
// and/or other materials provided with the distribution.
//
// * The name of Intel Corporation may not be used to endorse or promote products
// derived from this software without specific prior written permission.
//
// This software is provided by the copyright holders and contributors "as is" and
// any express or implied warranties, including, but not limited to, the implied
// warranties of merchantability and fitness for a particular purpose are disclaimed.
// In no event shall the Intel Corporation or contributors be liable for any direct,
// indirect, incidental, special, exemplary, or consequential damages
// (including, but not limited to, procurement of substitute goods or services;
// loss of use, data, or profits; or business interruption) however caused
// and on any theory of liability, whether in contract, strict liability,
// or tort (including negligence or otherwise) arising in any way out of
// the use of this software, even if advised of the possibility of such damage.
//
//M*/
#include "cvtest.h"
static const char* accum_param_names[] = { "size", "channels", "depth", "use_mask", 0 };
static const CvSize accum_sizes[] = {{30,30}, {320, 240}, {720,480}, {-1,-1}};
static const CvSize accum_whole_sizes[] = {{320,240}, {320, 240}, {720,480}, {-1,-1}};
static const int accum_depths[] = { CV_8U, CV_32F, CV_64F, -1 };
static const int accum_channels[] = { 1, 3, -1 };
class CV_AccumBaseTestImpl : public CvArrTest
{
public:
CV_AccumBaseTestImpl( const char* test_name, const char* test_funcs );
protected:
void get_test_array_types_and_sizes( int test_case_idx, CvSize** sizes, int** types );
double get_success_error_level( int test_case_idx, int i, int j );
void get_timing_test_array_types_and_sizes( int test_case_idx, CvSize** sizes, int** types,
CvSize** whole_sizes, bool *are_images );
double alpha;
};
CV_AccumBaseTestImpl::CV_AccumBaseTestImpl( const char* test_name, const char* test_funcs )
: CvArrTest( test_name, test_funcs, "" )
{
test_array[INPUT].push(NULL);
test_array[INPUT_OUTPUT].push(NULL);
test_array[REF_INPUT_OUTPUT].push(NULL);
test_array[TEMP].push(NULL);
test_array[MASK].push(NULL);
optional_mask = true;
element_wise_relative_error = false;
default_timing_param_names = 0;
depth_list = accum_depths;
size_list = accum_sizes;
whole_size_list = accum_whole_sizes;
cn_list = accum_channels;
return;
} // ctor
void CV_AccumBaseTestImpl::get_test_array_types_and_sizes( int test_case_idx,
CvSize** sizes, int** types )
{
CvRNG* rng = ts->get_rng();
int depth = cvTsRandInt(rng) % 3, cn = cvTsRandInt(rng) & 1 ? 3 : 1;
int accdepth = std::max((int)(cvTsRandInt(rng) % 2 + 1), depth);
int i, input_count = test_array[INPUT].size();
CvArrTest::get_test_array_types_and_sizes( test_case_idx, sizes, types );
depth = depth == 0 ? CV_8U : depth == 1 ? CV_32F : CV_64F;
accdepth = accdepth == 1 ? CV_32F : CV_64F;
accdepth = MAX(accdepth, depth);
for( i = 0; i < input_count; i++ )
types[INPUT][i] = CV_MAKETYPE(depth,cn);
types[INPUT_OUTPUT][0] = types[REF_INPUT_OUTPUT][0] = types[TEMP][0] = CV_MAKETYPE(accdepth,cn);
alpha = cvTsRandReal(rng);
return;
}
double CV_AccumBaseTestImpl::get_success_error_level( int /*test_case_idx*/, int /*i*/, int /*j*/ )
{
return CV_MAT_DEPTH(test_mat[INPUT_OUTPUT][0].type) < CV_64F ||
CV_MAT_DEPTH(test_mat[INPUT][0].type) == CV_32F ? FLT_EPSILON*100 : DBL_EPSILON*1000;
}
void CV_AccumBaseTestImpl::get_timing_test_array_types_and_sizes( int test_case_idx,
CvSize** sizes, int** types, CvSize** whole_sizes, bool* are_images )
{
CvArrTest::get_timing_test_array_types_and_sizes( test_case_idx, sizes, types,
whole_sizes, are_images );
types[INPUT_OUTPUT][0] = CV_MAKETYPE(MAX(CV_32F, CV_MAT_DEPTH(types[INPUT][0])),
CV_MAT_CN(types[INPUT][0]));
alpha = 0.333333333333333;
}
CV_AccumBaseTestImpl accum_base( "accum", "" );
class CV_AccumBaseTest : public CV_AccumBaseTestImpl
{
public:
CV_AccumBaseTest( const char* test_name, const char* test_funcs );
};
CV_AccumBaseTest::CV_AccumBaseTest( const char* test_name, const char* test_funcs )
: CV_AccumBaseTestImpl( test_name, test_funcs )
{
depth_list = 0;
size_list = 0;
whole_size_list = 0;
cn_list = 0;
default_timing_param_names = accum_param_names;
}
/// acc
class CV_AccTest : public CV_AccumBaseTest
{
public:
CV_AccTest();
protected:
void run_func();
void prepare_to_validation( int );
};
CV_AccTest::CV_AccTest(void)
: CV_AccumBaseTest( "accum-acc", "cvAcc" )
{
}
void CV_AccTest::run_func(void)
{
cvAcc( test_array[INPUT][0], test_array[INPUT_OUTPUT][0], test_array[MASK][0] );
}
void CV_AccTest::prepare_to_validation( int )
{
const CvMat* src = &test_mat[INPUT][0];
CvMat* dst = &test_mat[REF_INPUT_OUTPUT][0];
CvMat* temp = &test_mat[TEMP][0];
const CvMat* mask = test_array[MASK][0] ? &test_mat[MASK][0] : 0;
cvTsAdd( src, cvScalarAll(1.), dst, cvScalarAll(1.), cvScalarAll(0.), temp, 0 );
cvTsCopy( temp, dst, mask );
return;
}
CV_AccTest acc_test;
/// square acc
class CV_SquareAccTest : public CV_AccumBaseTest
{
public:
CV_SquareAccTest();
protected:
void run_func();
void prepare_to_validation( int );
};
CV_SquareAccTest::CV_SquareAccTest()
: CV_AccumBaseTest( "accum-squareacc", "cvSquareAcc" )
{
}
void CV_SquareAccTest::run_func()
{
cvSquareAcc( test_array[INPUT][0], test_array[INPUT_OUTPUT][0], test_array[MASK][0] );
}
void CV_SquareAccTest::prepare_to_validation( int )
{
const CvMat* src = &test_mat[INPUT][0];
CvMat* dst = &test_mat[REF_INPUT_OUTPUT][0];
CvMat* temp = &test_mat[TEMP][0];
const CvMat* mask = test_array[MASK][0] ? &test_mat[MASK][0] : 0;
cvTsMul( src, src, cvScalarAll(1.), temp );
cvTsAdd( temp, cvScalarAll(1.), dst, cvScalarAll(1.), cvScalarAll(0.), temp, 0 );
cvTsCopy( temp, dst, mask );
}
CV_SquareAccTest squareacc_test;
/// multiply acc
class CV_MultiplyAccTest : public CV_AccumBaseTest
{
public:
CV_MultiplyAccTest();
protected:
void run_func();
void prepare_to_validation( int );
};
CV_MultiplyAccTest::CV_MultiplyAccTest()
: CV_AccumBaseTest( "accum-mulacc", "cvMultiplyAcc" )
{
test_array[INPUT].push(NULL);
}
void CV_MultiplyAccTest::run_func()
{
cvMultiplyAcc( test_array[INPUT][0], test_array[INPUT][1],
test_array[INPUT_OUTPUT][0], test_array[MASK][0] );
}
void CV_MultiplyAccTest::prepare_to_validation( int )
{
const CvMat* src1 = &test_mat[INPUT][0];
const CvMat* src2 = &test_mat[INPUT][1];
CvMat* dst = &test_mat[REF_INPUT_OUTPUT][0];
CvMat* temp = &test_mat[TEMP][0];
const CvMat* mask = test_array[MASK][0] ? &test_mat[MASK][0] : 0;
cvTsMul( src1, src2, cvScalarAll(1.), temp );
cvTsAdd( temp, cvScalarAll(1.), dst, cvScalarAll(1.), cvScalarAll(0.), temp, 0 );
cvTsCopy( temp, dst, mask );
}
CV_MultiplyAccTest mulacc_test;
/// running average
class CV_RunningAvgTest : public CV_AccumBaseTest
{
public:
CV_RunningAvgTest();
protected:
void run_func();
void prepare_to_validation( int );
};
CV_RunningAvgTest::CV_RunningAvgTest()
: CV_AccumBaseTest( "accum-runavg", "cvRunningAvg" )
{
}
void CV_RunningAvgTest::run_func()
{
cvRunningAvg( test_array[INPUT][0], test_array[INPUT_OUTPUT][0],
alpha, test_array[MASK][0] );
}
void CV_RunningAvgTest::prepare_to_validation( int )
{
const CvMat* src = &test_mat[INPUT][0];
CvMat* dst = &test_mat[REF_INPUT_OUTPUT][0];
CvMat* temp = &test_mat[TEMP][0];
const CvMat* mask = test_array[MASK][0] ? &test_mat[MASK][0] : 0;
double a[1], b[1];
int accdepth = CV_MAT_DEPTH(test_mat[INPUT_OUTPUT][0].type);
CvMat A = cvMat(1,1,accdepth,a), B = cvMat(1,1,accdepth,b);
cvSetReal1D( &A, 0, alpha);
cvSetReal1D( &B, 0, 1 - cvGetReal1D(&A, 0));
cvTsAdd( src, cvScalarAll(cvGetReal1D(&A, 0)), dst, cvScalarAll(cvGetReal1D(&B, 0)), cvScalarAll(0.), temp, 0 );
cvTsCopy( temp, dst, mask );
}
CV_RunningAvgTest runavg_test;
/*M///////////////////////////////////////////////////////////////////////////////////////
//
// IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
//
// By downloading, copying, installing or using the software you agree to this license.
// If you do not agree to this license, do not download, install,
// copy or use the software.
//
//
// Intel License Agreement
// For Open Source Computer Vision Library
//
// Copyright (C) 2000, Intel Corporation, all rights reserved.
// Third party copyrights are property of their respective owners.
//
// Redistribution and use in source and binary forms, with or without modification,
// are permitted provided that the following conditions are met:
//
// * Redistribution's of source code must retain the above copyright notice,
// this list of conditions and the following disclaimer.
//
// * Redistribution's in binary form must reproduce the above copyright notice,
// this list of conditions and the following disclaimer in the documentation
// and/or other materials provided with the distribution.
//
// * The name of Intel Corporation may not be used to endorse or promote products
// derived from this software without specific prior written permission.
//
// This software is provided by the copyright holders and contributors "as is" and
// any express or implied warranties, including, but not limited to, the implied
// warranties of merchantability and fitness for a particular purpose are disclaimed.
// In no event shall the Intel Corporation or contributors be liable for any direct,
// indirect, incidental, special, exemplary, or consequential damages
// (including, but not limited to, procurement of substitute goods or services;
// loss of use, data, or profits; or business interruption) however caused
// and on any theory of liability, whether in contract, strict liability,
// or tort (including negligence or otherwise) arising in any way out of
// the use of this software, even if advised of the possibility of such damage.
//
//M*/
#include "cvtest.h"
#if 0
//extern "C"{
// #include "HighGUI.h"
//}
static char cTestName[] = "Image Adaptive Thresholding";
static char cTestClass[] = "Algorithm";
static char cFuncName[] = "cvAdaptThreshold";
static int aAdaptThreshold()
{
CvPoint *cp;
int parameter1 = 3;
double parameter2 = 10;
int width = 128;
int height = 128;
int kp = 5;
int nPoints2 = 20;
int fi = 0;
int a2 = 20;
int b2 = 25,xc,yc;
double pi = 3.1415926;
double lower, upper;
unsigned seed;
char rand;
AtsRandState state;
long diff_binary, diff_binary_inv;
int l,i,j;
IplImage *imBinary, *imBinary_inv, *imTo_zero, *imTo_zero_inv, *imInput, *imOutput;
CvSize size;
int code = TRS_OK;
// read tests params
if(!trsiRead( &width, "128", "image width" ))
return TRS_UNDEF;
if(!trsiRead( &height, "128", "image height" ))
return TRS_UNDEF;
// initialized image
l = width*height*sizeof(uchar);
cp = (CvPoint*) trsmAlloc(nPoints2*sizeof(CvPoint));
xc = (int)( width/2.);
yc = (int)( height/2.);
kp = nPoints2;
size.width = width;
size.height = height;
int xmin = width;
int ymin = height;
int xmax = 0;
int ymax = 0;
for(i=0;i<nPoints2;i++)
{
cp[i].x = (int)(a2*cos(2*pi*i/nPoints2)*cos(2*pi*fi/360.))-
(int)(b2*sin(2*pi*i/nPoints2)*sin(2*pi*fi/360.))+xc;
if(xmin> cp[i].x) xmin = cp[i].x;
if(xmax< cp[i].x) xmax = cp[i].x;
cp[i].y = (int)(a2*cos(2*pi*i/nPoints2)*sin(2*pi*fi/360.))+
(int)(b2*sin(2*pi*i/nPoints2)*cos(2*pi*fi/360.))+yc;
if(ymin> cp[i].y) ymin = cp[i].y;
if(ymax< cp[i].y) ymax = cp[i].y;
}
if(xmax>width||xmin<0||ymax>height||ymin<0) return TRS_FAIL;
// IPL image moment calculation
// create image
imBinary = cvCreateImage( size, 8, 1 );
imBinary_inv = cvCreateImage( size, 8, 1 );
imTo_zero = cvCreateImage( size, 8, 1 );
imTo_zero_inv = cvCreateImage( size, 8, 1 );
imOutput = cvCreateImage( size, 8, 1 );
imInput = cvCreateImage( size, 8, 1 );
int bgrn = 50;
int signal = 150;
memset(imInput->imageData,bgrn,l);
cvFillPoly(imInput, &cp, &kp, 1, cvScalarAll(signal));
// do noise
upper = 22;
lower = -upper;
seed = 345753;
atsRandInit( &state, lower, upper, seed );
uchar *input = (uchar*)imInput->imageData;
uchar *binary = (uchar*)imBinary->imageData;
uchar *binary_inv = (uchar*)imBinary_inv->imageData;
uchar *to_zero = (uchar*)imTo_zero->imageData;
uchar *to_zero_inv = (uchar*)imTo_zero_inv->imageData;
double *parameter = (double*)trsmAlloc(2*sizeof(double));
int step = imInput->widthStep;
for(i = 0; i<size.height; i++, input+=step, binary+=step, binary_inv+=step, to_zero+=step,to_zero_inv+=step)
{
for(j = 0; j<size.width; j++)
{
atsbRand8s( &state, &rand, 1);
if(input[j] == bgrn)
{
binary[j] = to_zero[j] = (uchar)0;
binary_inv[j] = (uchar)255;
to_zero_inv[j] = input [j] = (uchar)(bgrn + rand);
}
else
{
binary[j] = (uchar)255;
binary_inv[j] = to_zero_inv[j] = (uchar)0;
to_zero[j] = input[j] = (uchar)(signal + rand);
}
}
}
cvAdaptiveThreshold( imInput, imOutput, (double)255, CV_ADAPTIVE_THRESH_MEAN_C, CV_THRESH_BINARY, parameter1, parameter2 );
diff_binary = atsCompare1Db( (uchar*)imOutput->imageData, (uchar*)imBinary->imageData, l, 5);
cvAdaptiveThreshold( imInput, imOutput, (double)255, CV_ADAPTIVE_THRESH_MEAN_C, CV_THRESH_BINARY_INV, parameter1, parameter2 );
diff_binary_inv = atsCompare1Db( (uchar*)imOutput->imageData, (uchar*)imBinary_inv->imageData, l, 5);
if( diff_binary > 5 || diff_binary_inv > 5 )
code = TRS_FAIL;
cvReleaseImage(&imInput);
cvReleaseImage(&imOutput);
cvReleaseImage(&imBinary);
cvReleaseImage(&imBinary_inv);
cvReleaseImage(&imTo_zero);
cvReleaseImage(&imTo_zero_inv);
trsWrite( ATS_CON | ATS_LST | ATS_SUM, "diff_binary =%ld \n", diff_binary);
trsWrite( ATS_CON | ATS_LST | ATS_SUM, "diff_binary_inv =%ld \n", diff_binary_inv);
trsFree(parameter);
trsFree(cp);
return code;
}
void InitAAdaptThreshold( void )
{
/* Test Registartion */
trsReg(cFuncName,cTestName,cTestClass,aAdaptThreshold);
} /* InitAAdaptThreshold */
#endif
/* End of file. */
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
/*M///////////////////////////////////////////////////////////////////////////////////////
//
// IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
//
// By downloading, copying, installing or using the software you agree to this license.
// If you do not agree to this license, do not download, install,
// copy or use the software.
//
//
// Intel License Agreement
// For Open Source Computer Vision Library
//
// Copyright (C) 2000, Intel Corporation, all rights reserved.
// Third party copyrights are property of their respective owners.
//
// Redistribution and use in source and binary forms, with or without modification,
// are permitted provided that the following conditions are met:
//
// * Redistribution's of source code must retain the above copyright notice,
// this list of conditions and the following disclaimer.
//
// * Redistribution's in binary form must reproduce the above copyright notice,
// this list of conditions and the following disclaimer in the documentation
// and/or other materials provided with the distribution.
//
// * The name of Intel Corporation may not be used to endorse or promote products
// derived from this software without specific prior written permission.
//
// This software is provided by the copyright holders and contributors "as is" and
// any express or implied warranties, including, but not limited to, the implied
// warranties of merchantability and fitness for a particular purpose are disclaimed.
// In no event shall the Intel Corporation or contributors be liable for any direct,
// indirect, incidental, special, exemplary, or consequential damages
// (including, but not limited to, procurement of substitute goods or services;
// loss of use, data, or profits; or business interruption) however caused
// and on any theory of liability, whether in contract, strict liability,
// or tort (including negligence or otherwise) arising in any way out of
// the use of this software, even if advised of the possibility of such damage.
//
//M*/
#include "cvtest.h"
/* End of file. */
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
This diff is collapsed.
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment