Image::Pointer
VolumeVisualizationImagePreprocessor::Process(
Image::Pointer m_originalCT, Image::Pointer m_originalLiverMask)
{
VVP_INFO << "Processing...";
// converting mitk image -> itk image
CTImage::Pointer CTImageWork = CTImage::New();
CastToItkImage( m_originalCT, CTImageWork );
// converting mitk image -> itk image
BinImage::Pointer BinImageMask = BinImage::New();
CastToItkImage( m_originalLiverMask, BinImageMask );
DetermineBoundingBox( BinImageMask );
if( m_MaxX < m_MinX
|| m_MaxY < m_MinY
|| m_MaxZ < m_MinZ )
return 0;
CTImageWork = Gaussian(Crop( CTImageWork ));
BinImageMask = Crop( BinImageMask );
CTImage::Pointer itkResult =Composite(CTImageWork,BinImageMask,Dilate(BinImageMask),Erode(BinImageMask));
mitk::Image::Pointer mitkResult= mitk::Image::New();
mitk::CastToMitkImage( itkResult, mitkResult ); //TODO here we can perhaps save memory
VVP_INFO << "Finished...";
return mitkResult;
}
void CGraphicsComponent::NativeBlitAndroid(int32_t x, int32_t y, int32_t aWidth, int32_t aHeight,
int32_t cropLeft, int32_t cropTop, int32_t cropRight, int32_t cropBottom, int32_t orgWidth, int32_t orgHeight)
{
const bool bCrop = (cropLeft != 0) || (cropTop != 0) || (cropRight != orgWidth) || (cropBottom != orgHeight);
if (bCrop) {
Crop(cropLeft, cropTop, cropRight, cropBottom);
}
glDrawTexiOES(x, y, 0, aWidth, aHeight);
if (glGetError() != 0) LOG_ERROR("Error!");
if (bCrop) {
Crop(0, 0, orgWidth, orgHeight);
}
}
void FaceCrop::CropAllGrayLevelFace(vector<FaceInfo> *cropFaceSet){
//for(vector<FP>::iterator iter=fpSet.begin() ; iter!=fpSet.end() ; iter++ ){
// Crop(iter->lefteye,iter->righteye,iter->nose,iter->mouth);
// saveCropImage();
//}
FaceInfo temp;
for(int i=0 ; i<fpSet.size() ; i++ ){
if(Crop(fpSet[i].lefteye,fpSet[i].righteye,fpSet[i].nose,fpSet[i].mouth)==true){
IplImage* grayImg=cvCreateImage(cvSize(normalizeImg->width,normalizeImg->height),IPL_DEPTH_8U,1);
cvCvtColor(normalizeImg,grayImg,CV_BGR2GRAY);
cvReleaseImage(&normalizeImg);
temp.face=grayImg;
temp.leftdown=leftdown;
temp.leftTop=leftTop;
temp.rightdown=rightdown;
temp.rightTop=rightTop;
cropFaceSet->push_back(temp);
}
}
//for(vector<IplImage*>::iterator iter=cropFaceSet.begin(); iter!=cropFaceSet.end() ;iter++){
// cvNamedWindow("Img",1);
// cvShowImage("Img",*iter);
// cvWaitKey(0);
//}
}
void check_world_resources(World_map* world)
{
if (!world) {
return;
}
int land = world->land_count();
int size = world->get_size() * world->get_size();
float land_percent = float((100.0 * float(land)) / size);
debugmsg("Land tiles: %d/%d (%f percent)", land, size, land_percent);
for (int i = 0; i < CROP_MAX; i++) {
Crop crop = Crop(i);
int crop_count = world->crop_count(crop);
float crop_percent = float((100.0 * float(crop_count)) / size);
float crop_land_percent = float((100.0 * float(crop_count)) / land);
debugmsg("%s: %d/%d/%d (%f/%f percent, should be %d)",
Crop_data[crop]->name.c_str(), crop_count, land, size,
crop_land_percent, crop_percent, Crop_data[crop]->percentage);
}
for (int i = 0; i < MINERAL_MAX; i++) {
Mineral mineral = Mineral(i);
int mineral_count = world->mineral_count(mineral);
float mineral_percent = float((100.0 * float(mineral_count)) / size);
float mineral_land_percent = float((100.0 * float(mineral_count)) / land);
debugmsg("%s: %d/%d/%d (%f/%f percent, should be %d)",
Mineral_data[mineral]->name.c_str(), mineral_count, land, size,
mineral_land_percent, mineral_percent,
Mineral_data[mineral]->percentage);
}
}
PolynomialMod2 PolynomialMod2::AllOnes(unsigned int bitLength)
{
PolynomialMod2 result((word)0, bitLength);
SetWords(result.reg, ~(word)0, result.reg.size());
if (bitLength%WORD_BITS)
result.reg[result.reg.size()-1] = (word)Crop(result.reg[result.reg.size()-1], bitLength%WORD_BITS);
return result;
}
void PolynomialMod2::Randomize(RandomNumberGenerator &rng, size_t nbits)
{
const size_t nbytes = nbits/8 + 1;
SecByteBlock buf(nbytes);
rng.GenerateBlock(buf, nbytes);
buf[0] = (byte)Crop(buf[0], nbits % 8);
Decode(buf, nbytes);
}
PolynomialMod2 PolynomialMod2::AllOnes(size_t bitLength)
{
PolynomialMod2 result((word)0, bitLength);
SetWords(result.reg, word(SIZE_MAX), result.reg.size());
if (bitLength%WORD_BITS)
result.reg[result.reg.size()-1] = (word)Crop(result.reg[result.reg.size()-1], bitLength%WORD_BITS);
return result;
}
DecodingResult PSSR_MEM_Base::RecoverMessageFromRepresentative(
HashTransformation &hash, HashIdentifier hashIdentifier, bool messageEmpty,
byte *representative, size_t representativeBitLength,
byte *recoverableMessage) const
{
assert(representativeBitLength >= MinRepresentativeBitLength(hashIdentifier.second, hash.DigestSize()));
const size_t u = hashIdentifier.second + 1;
const size_t representativeByteLength = BitsToBytes(representativeBitLength);
const size_t digestSize = hash.DigestSize();
const size_t saltSize = SaltLen(digestSize);
const byte *const h = representative + representativeByteLength - u - digestSize;
SecByteBlock digest(digestSize);
hash.Final(digest);
DecodingResult result(0);
bool &valid = result.isValidCoding;
size_t &recoverableMessageLength = result.messageLength;
valid = (representative[representativeByteLength - 1] == (hashIdentifier.second ? 0xcc : 0xbc)) && valid;
valid = VerifyBufsEqual(representative + representativeByteLength - u, hashIdentifier.first, hashIdentifier.second) && valid;
GetMGF().GenerateAndMask(hash, representative, representativeByteLength - u - digestSize, h, digestSize);
if (representativeBitLength % 8 != 0)
representative[0] = (byte)Crop(representative[0], representativeBitLength % 8);
// extract salt and recoverableMessage from DB = 00 ... || 01 || M || salt
byte *salt = representative + representativeByteLength - u - digestSize - saltSize;
byte *M = std::find_if(representative, salt-1, std::bind2nd(std::not_equal_to<byte>(), 0));
recoverableMessageLength = salt-M-1;
if (*M == 0x01
&& (size_t)(M - representative - (representativeBitLength % 8 != 0)) >= MinPadLen(digestSize)
&& recoverableMessageLength <= MaxRecoverableLength(representativeBitLength, hashIdentifier.second, digestSize))
{
memcpy(recoverableMessage, M+1, recoverableMessageLength);
}
else
{
recoverableMessageLength = 0;
valid = false;
}
// verify H = hash of M'
byte c[8];
PutWord(false, BIG_ENDIAN_ORDER, c, (word32)SafeRightShift<29>(recoverableMessageLength));
PutWord(false, BIG_ENDIAN_ORDER, c+4, word32(recoverableMessageLength << 3));
hash.Update(c, 8);
hash.Update(recoverableMessage, recoverableMessageLength);
hash.Update(digest, digestSize);
hash.Update(salt, saltSize);
valid = hash.Verify(h) && valid;
if (!AllowRecovery() && valid && recoverableMessageLength != 0)
{throw NotImplemented("PSSR_MEM: message recovery disabled");}
return result;
}
cv::Mat Barcode_Locator::DrawBarLoc(cv::Mat img_input){
img_input.copyTo(this->img);
cv::Mat grad_x , grad_y;
cv::Mat abs_grad_x , abs_grad_y;
int scale = 1;
int delta = 0;
int ddepth = CV_16S;
//---------------------------------Gradient Calculation------------------------------------
cv::cvtColor(this->img,this->img_gray,CV_BGR2GRAY);
cv::GaussianBlur( this->img_gray, this->img_gray, cv::Size(3,3), 0, 0, cv::BORDER_DEFAULT );
#pragma omp parallel sections
{
#pragma omp section
{
/// Gradient X
cv::Sobel( this->img_gray, grad_x, ddepth, 1, 0, 3, scale, delta, cv::BORDER_DEFAULT );
cv::convertScaleAbs(grad_x , abs_grad_x);
}
#pragma omp section
{
/// Gradient Y
cv::Sobel( this->img_gray, grad_y, ddepth, 0, 1, 3, scale, delta, cv::BORDER_DEFAULT );
cv::convertScaleAbs(grad_y , abs_grad_y);
}
}
//--------------------------------Gradient difference between x and y-------------------
cv::Mat grad_diff;
grad_diff = cv::abs(abs_grad_x) - cv::abs(abs_grad_y);
//region normalization
cv::blur(grad_diff,this->img_smooth,cv::Size(31,31),cv::Point(-1,-1));
//find the location of the max value
double minval, maxval;
cv::Point minloc, maxloc;
cv::minMaxLoc(this->img_smooth, &minval, &maxval, &minloc, &maxloc);
cv::Mat Result;
if(maxval > 130.0){
// thresholding by OTSU method
cv::Mat thres;
cv::threshold(this->img_smooth,thres,0,255,CV_THRESH_BINARY | CV_THRESH_OTSU);
cv::Point MaxPoint;
MaxPoint.x = maxloc.x;
MaxPoint.y = maxloc.y;
cv::Rect A = Crop( thres , MaxPoint );
this->img.copyTo(Result);
cv::rectangle(Result , A , cv::Scalar(255,0,0) );
}
return Result;
}
void FaceCrop::CropAllFace(){
//for(vector<FP>::iterator iter=fpSet.begin() ; iter!=fpSet.end() ; iter++ ){
// Crop(iter->lefteye,iter->righteye,iter->nose,iter->mouth);
// saveCropImage();
//}
for(int i=0 ; i<fpSet.size() ; i++ ){
if(Crop(fpSet[i].lefteye,fpSet[i].righteye,fpSet[i].nose,fpSet[i].mouth)==true){
saveCropImage(i);
}
}
}
void FaceCrop::CropAllFace(vector<IplImage*> *cropFaceSet){
for(int i=0 ; i<fpSet.size() ; i++ ){
if(Crop(fpSet[i].lefteye,fpSet[i].righteye,fpSet[i].nose,fpSet[i].mouth)==true){
cropFaceSet->push_back(normalizeImg);
}
}
}
void GenerateRLE16::CreateFromImage(const Image* image, bool dither)
{
int minX=0;
int minY=0;
int maxX=0;
int maxY=0;
// Crop image
Crop(image,&minX,&minY,&maxX,&maxY);
if (maxX<minX || maxY<minY)
{
return;
}
hPitch_=(unsigned short)(maxX-minX+1);
vPitch_=(unsigned short)(maxY-minY+1);
hOffset_=(unsigned short)minX;
vOffset_=(unsigned short)minY;
// First, create 16-bit version
unsigned short* data=0;
unsigned char* mask=0;
Palettize(image,&data,&mask,dither);
// Create RLE data
opaqueSize_=GetRLESize(data,mask);
if (opaqueSize_>0)
{
opaqueData_=static_cast<unsigned char*>(Malloc(opaqueSize_));
CreateRLE(data,mask,opaqueData_);
}
// Create RLE mask
alphaSize_=GetRLESize_Alpha(data,mask);
if (alphaSize_>0)
{
alphaData_=static_cast<unsigned char*>(Malloc(alphaSize_));
CreateRLE_Alpha(data,mask,alphaData_);
}
// Release temp stuff
if (data)
{
Free(data);
}
if (mask)
{
Free(mask);
}
}
void FaceCrop::CropAllGrayLevelFace(vector<IplImage*> *cropFaceSet){
for(int i=0 ; i<fpSet.size() ; i++ ){
if(Crop(fpSet[i].lefteye,fpSet[i].righteye,fpSet[i].nose,fpSet[i].mouth)==true){
IplImage* grayImg=cvCreateImage(cvSize(normalizeImg->width,normalizeImg->height),IPL_DEPTH_8U,1);
cvCvtColor(normalizeImg,grayImg,CV_BGR2GRAY);
cropFaceSet->push_back(grayImg);
cvReleaseImage(&normalizeImg);
}
}
}
word32 RandomNumberGenerator::GenerateWord32(word32 min, word32 max)
{
const word32 range = max-min;
const unsigned int maxBits = BitPrecision(range);
word32 value;
do
{
GenerateBlock((byte *)&value, sizeof(value));
value = Crop(value, maxBits);
} while (value > range);
return value+min;
}
word32 RandomNumberGenerator::GenerateWord32(word32 min, word32 max)
{
word32 range = max-min;
const int maxBytes = BytePrecision(range);
const int maxBits = BitPrecision(range);
word32 value;
do
{
value = 0;
for (int i=0; i<maxBytes; i++)
value = (value << 8) | GenerateByte();
value = Crop(value, maxBits);
} while (value > range);
return value+min;
}
void InterpolateImage(Image& img, const Rect& _rc)
{
Rect rc = _rc & img.GetSize();
Image m = Crop(img, rc);
TimeStop tm;
Image imp = CreateImage(rc.GetSize(), Null);
Over(imp, Point(0, 0), m, m.GetSize());
Progress pi("Interpolating...");
for(int qq = 0; qq < 2000; qq++) {
InterpolateFilter f;
f.todo = 0;
imp = Filter(imp, f);
Over(imp, Point(0, 0), m, m.GetSize());
if(f.todo == 0)
break;
if(pi.SetCanceled(qq, 2000))
break;
}
Copy(img, rc.TopLeft(), imp, imp.GetSize());
}
BTRESULT BTCImageDataEx::RotateEx(double dAngle, const enum BTDirection& Direction /* = Right */, BTCOLORREF colBackground /* = 0x00000000 */, bool bCrop /* = true */)
{
if(!m_pBitmapInfo)
return BT_E_POINTER;
long lOldWidth = GetWidth();
long lOldHeight = GetHeight();
if( false == Rotate( dAngle, Direction, colBackground))
return BT_S_FALSE;
if( true == bCrop)
{
long x = (GetWidth() / 2) - (lOldWidth / 2);
long y = (GetHeight() / 2) - (lOldHeight / 2);
return Crop( x, y, lOldWidth, lOldHeight) ? BT_S_OK : BT_S_FALSE;
}
return BT_S_OK;
}
void PSSR_MEM_Base::ComputeMessageRepresentative(RandomNumberGenerator &rng,
const byte *recoverableMessage, size_t recoverableMessageLength,
HashTransformation &hash, HashIdentifier hashIdentifier, bool messageEmpty,
byte *representative, size_t representativeBitLength) const
{
assert(representativeBitLength >= MinRepresentativeBitLength(hashIdentifier.second, hash.DigestSize()));
const size_t u = hashIdentifier.second + 1;
const size_t representativeByteLength = BitsToBytes(representativeBitLength);
const size_t digestSize = hash.DigestSize();
const size_t saltSize = SaltLen(digestSize);
byte *const h = representative + representativeByteLength - u - digestSize;
SecByteBlock digest(digestSize), salt(saltSize);
hash.Final(digest);
rng.GenerateBlock(salt, saltSize);
// compute H = hash of M'
byte c[8];
PutWord(false, BIG_ENDIAN_ORDER, c, (word32)SafeRightShift<29>(recoverableMessageLength));
PutWord(false, BIG_ENDIAN_ORDER, c+4, word32(recoverableMessageLength << 3));
hash.Update(c, 8);
hash.Update(recoverableMessage, recoverableMessageLength);
hash.Update(digest, digestSize);
hash.Update(salt, saltSize);
hash.Final(h);
// compute representative
GetMGF().GenerateAndMask(hash, representative, representativeByteLength - u - digestSize, h, digestSize, false);
byte *xorStart = representative + representativeByteLength - u - digestSize - salt.size() - recoverableMessageLength - 1;
xorStart[0] ^= 1;
xorbuf(xorStart + 1, recoverableMessage, recoverableMessageLength);
xorbuf(xorStart + 1 + recoverableMessageLength, salt, salt.size());
memcpy(representative + representativeByteLength - u, hashIdentifier.first, hashIdentifier.second);
representative[representativeByteLength - 1] = hashIdentifier.second ? 0xcc : 0xbc;
if (representativeBitLength % 8 != 0)
representative[0] = (byte)Crop(representative[0], representativeBitLength % 8);
}
void FaceCrop::CropAllFace(vector<FaceInfo> *cropFaceSet){
//for(vector<FP>::iterator iter=fpSet.begin() ; iter!=fpSet.end() ; iter++ ){
// Crop(iter->lefteye,iter->righteye,iter->nose,iter->mouth);
// saveCropImage();
//}
FaceInfo temp;
for(int i=0 ; i<fpSet.size() ; i++ ){
if(Crop(fpSet[i].lefteye,fpSet[i].righteye,fpSet[i].nose,fpSet[i].mouth)==true){
temp.face=normalizeImg;
temp.leftdown=leftdown;
temp.leftTop=leftTop;
temp.rightdown=rightdown;
temp.rightTop=rightTop;
cropFaceSet->push_back(temp);
}
}
//for(vector<IplImage*>::iterator iter=cropFaceSet.begin(); iter!=cropFaceSet.end() ;iter++){
// cvNamedWindow("Img",1);
// cvShowImage("Img",*iter);
// cvWaitKey(0);
//}
}
BinaryVector *BinaryVector::CropVector(int start, int count = -1) {
int endIndex = count == -1 ? GetRowCount() - 1 : (start + count - 1);
BinaryMatrix *croped = Crop(0, 0, start, endIndex);
};
cv::Mat Barcode_Locator::GetBarLoc(cv::Mat img_input){
this->img = img_input;
cv::Mat grad_x , grad_y;
cv::Mat abs_grad_x , abs_grad_y;
int scale = 1;
int delta = 0;
int ddepth = CV_16S;
//---------------------------------Gradient Calculation------------------------------------
cv::cvtColor(this->img,this->img_gray,CV_BGR2GRAY);
cv::GaussianBlur( this->img_gray, this->img_gray, cv::Size(3,3), 0, 0, cv::BORDER_DEFAULT );
#pragma omp parallel sections
{
#pragma omp section
{
/// Gradient X
cv::Sobel( this->img_gray, grad_x, ddepth, 1, 0, 3, scale, delta, cv::BORDER_DEFAULT );
cv::convertScaleAbs(grad_x , abs_grad_x);
}
#pragma omp section
{
/// Gradient Y
cv::Sobel( this->img_gray, grad_y, ddepth, 0, 1, 3, scale, delta, cv::BORDER_DEFAULT );
cv::convertScaleAbs(grad_y , abs_grad_y);
}
}
//cv::imshow("grad_x",grad_x);
//cv::imshow("grad_y",grad_y);
//cv::imshow("abs_x",abs_grad_x);
//cv::imshow("abs_y",abs_grad_y);
//--------------------------------Gradient difference between x and y-------------------
cv::Mat grad_diff;
grad_diff = cv::abs(abs_grad_x) - cv::abs(abs_grad_y);
//cv::imshow("diff",grad_diff);
cv::blur(grad_diff,this->img_smooth,cv::Size(31,31),cv::Point(-1,-1));//region normalization
//cv::imshow("smooth",this->img_smooth);
//find the location of the max value
double minval, maxval;
cv::Point minloc, maxloc;
cv::minMaxLoc(this->img_smooth, &minval, &maxval, &minloc, &maxloc);
//cout << "Max value : " << maxval << endl;
//cv::Mat Result1;
cv::Mat Result;
if(maxval > 130.0 && maxloc.x > 0 && maxloc.y > 0){
// thresholding by OTSU method
cv::Mat thres;
cv::threshold(this->img_smooth,thres,0,255,CV_THRESH_BINARY | CV_THRESH_OTSU);
//cv::imshow("thres",thres);
cv::Point MaxPoint;
MaxPoint.x = maxloc.x;
MaxPoint.y = maxloc.y;
cv::Rect A = Crop( thres , MaxPoint );
if(A.width >= 0 && A.height >= 0){
emit sendBarcodeLocation(A);
emit sendIsBarcodeLocated(true);
//cv::rectangle(this->img , A , cv::Scalar(255,0,0) );
//cv::imshow("REs",this->img);
Result = this->img_gray(A);
//cv::Mat Result;
cv::resize(Result,Result,cv::Size(1.2*Result.cols,1.2*Result.rows));
//cv::imshow("big",Result);
}
}else{
emit sendIsBarcodeLocated(false);
}
return Result;
}
bool Building::load_data(std::istream& data)
{
int tmptype;
data >> tmptype;
if (tmptype <= 0 || tmptype >= BUILD_MAX) {
debugmsg("Building loaded type of %d (range is 1 to %d).",
tmptype, BUILD_MAX - 1);
return false;
}
type = Building_type(tmptype);
data >> open >> pos.x >> pos.y >> construction_left >> workers;
crops_grown.clear();
data >> field_output;
int num_crops;
data >> num_crops;
for (int i = 0; i < num_crops; i++) {
int tmpcrop, crop_amt;
data >> tmpcrop >> crop_amt;
if (tmpcrop <= 0 || tmpcrop >= CROP_MAX) {
debugmsg("Building loaded crop %d/%d; type %d (range is 1 to %d).",
i, num_crops, tmpcrop, CROP_MAX - 1);
return false;
}
crops_grown.push_back( Crop_amount( Crop(tmpcrop), crop_amt ) );
}
minerals_mined.clear();
data >> shaft_output;
int num_mins;
data >> num_mins;
for (int i = 0; i < num_mins; i++) {
int tmpmin, min_amt;
data >> tmpmin >> min_amt;
if (tmpmin <= 0 || tmpmin >= MINERAL_MAX) {
debugmsg("Building loaded mineral %d/%d; type %d (range is 1 to %d).",
i, num_mins, tmpmin, MINERAL_MAX - 1);
return false;
}
minerals_mined.push_back( Mineral_amount( Mineral(tmpmin), min_amt ) );
}
data >> hunter_level;
int tmptarget, tmpaction;
data >> tmptarget >> tmpaction;
if (tmptarget >= ANIMAL_MAX) {
debugmsg("Building loaded hunting target %d (range is 1 to %d).",
tmptarget, ANIMAL_MAX - 1);
return false;
}
hunting_target = Animal(tmptarget);
if (tmpaction >= ANIMAL_ACT_MAX) {
debugmsg("Building loaded hunting action %d (range is 1 to %d).",
tmpaction, ANIMAL_ACT_MAX - 1);
return false;
}
hunting_action = Animal_action(tmpaction);
int queue_size;
data >> queue_size;
for (int i = 0; i < queue_size; i++) {
Recipe tmp_recipe;
if (!tmp_recipe.load_data(data)) {
debugmsg("Building failed to load recipe %d/%d.", i, queue_size);
return false;
}
int recipe_amt;
data >> recipe_amt;
build_queue.push_back( Recipe_amount( tmp_recipe, recipe_amt ) );
}
return true;
}
