static void
autovscale(DDLSymbolTable *st, float *vmin, float *vmax)
{
int i;
int n;
float min;
float max;
// Find max and min values in the data
int npts = (get_image_width(st) * get_image_height(st)
* get_image_depth(st));
get_min_max(st, &min, &max);
// Get intensity distribution
int nbins = 10000;
int *histogram = new int[nbins];
get_histogram(st, min, max, histogram, nbins);
// Estimate percentile points from distribution
int percentile = (int)(0.01 * npts);
if (percentile < 1) percentile = 1;
float scale = (nbins - 1) / (max - min);
for (i=n=0; n<percentile && i<nbins; n += histogram[i++]);
*vmin = min + (i-1) / scale;
for (i=nbins, n=0; n<percentile && i>0; n += histogram[--i]);
*vmax = min + i / scale;
// Set vmin to 0 if it looks plausible
if (*vmin > 0 && *vmin / *vmax < 0.05){
*vmin = 0;
}
delete [] histogram;
}
void fadc_fit_heights(std::string fadc_id,std::string hist_type)
{
/*****************************************************************/
// Prepare the canvas
gStyle->SetOptFit(1111);
TCanvas *AlCapCanvas = (TCanvas *) gROOT->GetListOfCanvases()->At(0);
AlCapCanvas->Clear();
AlCapCanvas->Divide(4,2);
// gROOT->ProcessLine(".L common/get_histogram.C"); // get_histogram() is called here
/*****************************************************************/
const int n_channels = 8;
std::string bank_names[n_channels] = {"Na", "Nb", "Nc", "Nd", "Ne", "Nf", "Ng", "Nh"};
std::string name;
double mean = 0;
double rms = 0;
for (int iChn = 0; iChn < n_channels; iChn++) {
name=bank_names[iChn]+fadc_id;
TH1* hist = get_histogram(name, hist_type);
mean = hist->GetMean();
rms = hist->GetRMS();
AlCapCanvas->cd(iChn+1);
if (hist->Integral()!=0) {
TF1* gaus = new TF1("gaus","gaus",mean-rms,mean+rms);
hist->Fit("gaus","Q");
hist->GetXaxis()->SetRange(mean-2*rms,mean+2*rms);
hist->Draw();
}
}
}
void dsp::ASPUnpacker::unpack ()
{
const uint64_t ndat = input->get_ndat();
const unsigned npol = input->get_npol();
const unsigned ndim = input->get_ndim();
const unsigned nskip = npol * ndim;
bool swap_pol=false, swap_dim=false;
#if HAVE_pdev
const PdevFile *pd = NULL;
try
{
pd = get_Input<PdevFile>();
swap_pol = pd->swap_poln();
swap_dim = pd->swap_dim();
}
catch (Error &error)
{
swap_pol = false;
swap_dim = false;
}
#endif
//cerr << "npol=" << npol << " ndim=" << ndim << std::endl;
for (unsigned ipol=0; ipol<npol; ipol++) {
for (unsigned idim=0; idim<ndim; idim++) {
unsigned off;
if (swap_pol)
off = (npol - ipol - 1) * ndim;
else
off = ipol * ndim;
if (swap_dim)
off += (ndim - idim - 1);
else
off += idim;
//unsigned off = ipol * ndim + idim;
//cerr << "ipol=" << ipol << " idim=" << idim << " off=" << off
// << std::endl;
const char* from = reinterpret_cast<const char*>(input->get_rawptr()+off);
float* into = output->get_datptr (0, ipol) + idim;
unsigned long* hist = get_histogram (off);
for (unsigned bt = 0; bt < ndat; bt++) {
hist[ (unsigned char) *from ] ++;
*into = float(int( (signed char) *from ));
from += nskip;
into += ndim;
}
}
}
}
vec_u32 ImgProcessor::get_cumulative_histogram(mat_u8 *gray)
{
vec_u32 histogram = get_histogram(gray);
// get cumulative histogram
vec_u32 c_histogram = vec_u32(255,0);
c_histogram[0] = histogram[0];
for (int i=1; i<255; i++)
c_histogram[i] = c_histogram[i-1] + histogram[i];
return c_histogram;
}
void fadc_82_shapes()
{
/*****************************************************************/
// Prepare the canvas
gStyle->SetOptStat("ne");
TCanvas *AlCapCanvas = (TCanvas *) gROOT->GetListOfCanvases()->At(0);
AlCapCanvas->Clear();
AlCapCanvas->Divide(4,2);
gROOT->ProcessLine(".L modules/common/get_histogram.C+");
/*****************************************************************/
std::string hist_type = "Shapes";
const int n_channels = 8;
std::string bank_names[n_channels] = {"Na82", "Nb82", "Nc82", "Nd82", "Ne82", "Nf82", "Ng82", "Nh82"};
for (int iChn = 0; iChn < n_channels; iChn++) {
TH1* hist = get_histogram(bank_names[iChn], hist_type);
if (hist) {
AlCapCanvas->cd(iChn+1);
hist->Draw("COLZ");
}
}
}
int main(int argc, char* argv[]) {
// declarations
struct stat st;
unsigned int i, buffer_size;
struct timespec begin, end;
char *buffer;
histogram_t histogram = {0};
char *filename = "war_and_peace.txt";
long num_threads = 1, repetitions=0;
// argument handling
if (argc < 2 || argc > 4) {
printf("usage: %s filename [#threads] [#repetition]\n", argv[0]);
return 1;
}
if (argc >= 2)
filename = argv[1];
if (argc >= 3)
if ((num_threads = strtol(argv[2], NULL, 0)) == 0 || num_threads < 0) {
fprintf(stderr, "#threads not valid!\n");
return 1;
}
if (argc >= 4)
if ((repetitions = strtol(argv[3], NULL, 0)) == 0 || repetitions < 0) {
fprintf(stderr, "#repetition not valid!\n");
return 1;
}
printf("\nProcess %s by %ld thread(s) with %ld repetition(s)\n\n",
filename, num_threads, repetitions);
printf(" main will get file size...");
// get file size and allocate array
stat(filename, &st);
buffer_size = (unsigned int)st.st_size * (repetitions+1);
buffer = (char*)malloc(buffer_size);
printf("main allocated array");
// open file and read all characters
FILE *fp = fopen(filename, "r");
if (fp == NULL) {
fprintf(stderr, "Could not open file %s", filename);
exit(EXIT_FAILURE);
}
if (fread(buffer, 1, st.st_size, fp) == 0) {
fprintf(stderr, "Could not read from file %s", filename);
exit(EXIT_FAILURE);
}
// [optional] do the repetition
for (i = 1; i <= repetitions; i++)
memcpy(buffer + i*st.st_size, buffer, st.st_size);
// set the buffer
printf("main sets bufer");
set_buffer(buffer, buffer_size);
// build the histogram
clock_gettime(CLOCK_MONOTONIC, &begin);
printf("main calls histogram");
get_histogram(histogram, num_threads);
clock_gettime(CLOCK_MONOTONIC, &end);
free(buffer);
print_histogram(histogram);
printf("\n\nTime: %.5f seconds\n", ((double)end.tv_sec + 1.0e-9*end.tv_nsec) -
((double)begin.tv_sec + 1.0e-9*begin.tv_nsec));
return 0;
}
int main() {
// Don't associate histograms with TFiles so we can delete them
TH1::AddDirectory(false);
// Set our style
set_plot_style();
// Get the histograms
const std::string INPUT_FILE =
"/data/whybee0a/user/gude_2/IDPlots/20150416/2012_ALL_hadded.root";
const std::string INPUT_MC_FILE =
"/data/whybee0a/user/gude_2/IDPlots/20150416/MadGraph_hadded.root";
// Load the histograms
// Data
std::unique_ptr<TH1D> h_r9 = get_histogram(INPUT_FILE, "IDPlotter/r9");
std::unique_ptr<TH1D> h_sigma_ieta_ieta_eb = get_histogram(INPUT_FILE, "IDPlotter/sieie_eb");
std::unique_ptr<TH1D> h_sigma_ieta_ieta_ee = get_histogram(INPUT_FILE, "IDPlotter/sieie_ee");
std::unique_ptr<TH1D> h_he = get_histogram(INPUT_FILE, "IDPlotter/he");
std::unique_ptr<TH1D> h_deta = get_histogram(INPUT_FILE, "IDPlotter/deta");
std::unique_ptr<TH1D> h_dphi = get_histogram(INPUT_FILE, "IDPlotter/dphi");
std::unique_ptr<TH1D> h_track_iso = get_histogram(INPUT_FILE, "IDPlotter/track_iso");
std::unique_ptr<TH1D> h_ecal_iso = get_histogram(INPUT_FILE, "IDPlotter/ecal_iso");
std::unique_ptr<TH1D> h_hcal_iso = get_histogram(INPUT_FILE, "IDPlotter/hcal_iso");
std::unique_ptr<TH1D> h_1oe_1op = get_histogram(INPUT_FILE, "IDPlotter/1oe_1op");
std::unique_ptr<TH1D> h_d0 = get_histogram(INPUT_FILE, "IDPlotter/d0");
std::unique_ptr<TH1D> h_dz = get_histogram(INPUT_FILE, "IDPlotter/dz");
std::unique_ptr<TH1D> h_mhits = get_histogram(INPUT_FILE, "IDPlotter/mhits");
std::unique_ptr<TH1D> h_iso = get_histogram(INPUT_FILE, "IDPlotter/iso");
std::unique_ptr<TH1D> h_nmiss = get_histogram(INPUT_FILE, "IDPlotter/mhits");
// MC
std::unique_ptr<TH1D> h_r9_mc = get_histogram(INPUT_MC_FILE, "IDPlotter/r9");
std::unique_ptr<TH1D> h_sigma_ieta_ieta_eb_mc = get_histogram(INPUT_MC_FILE, "IDPlotter/sieie_eb");
std::unique_ptr<TH1D> h_sigma_ieta_ieta_ee_mc = get_histogram(INPUT_MC_FILE, "IDPlotter/sieie_ee");
std::unique_ptr<TH1D> h_he_mc = get_histogram(INPUT_MC_FILE, "IDPlotter/he");
std::unique_ptr<TH1D> h_deta_mc = get_histogram(INPUT_MC_FILE, "IDPlotter/deta");
std::unique_ptr<TH1D> h_dphi_mc = get_histogram(INPUT_MC_FILE, "IDPlotter/dphi");
std::unique_ptr<TH1D> h_track_iso_mc = get_histogram(INPUT_MC_FILE, "IDPlotter/track_iso");
std::unique_ptr<TH1D> h_ecal_iso_mc = get_histogram(INPUT_MC_FILE, "IDPlotter/ecal_iso");
std::unique_ptr<TH1D> h_hcal_iso_mc = get_histogram(INPUT_MC_FILE, "IDPlotter/hcal_iso");
std::unique_ptr<TH1D> h_1oe_1op_mc = get_histogram(INPUT_MC_FILE, "IDPlotter/1oe_1op");
std::unique_ptr<TH1D> h_d0_mc = get_histogram(INPUT_MC_FILE, "IDPlotter/d0");
std::unique_ptr<TH1D> h_dz_mc = get_histogram(INPUT_MC_FILE, "IDPlotter/dz");
std::unique_ptr<TH1D> h_mhits_mc = get_histogram(INPUT_MC_FILE, "IDPlotter/mhits");
std::unique_ptr<TH1D> h_iso_mc = get_histogram(INPUT_MC_FILE, "IDPlotter/iso");
std::unique_ptr<TH1D> h_nmiss_mc = get_histogram(INPUT_MC_FILE, "IDPlotter/mhits");
// Write pdfs
const std::string NO_CHANGE = "";
const double NO_LINE = -100;
write_plot(h_r9, h_r9_mc, "r9.pdf", 50, "R9", NO_LINE, 0.94, 0, 1);
write_plot(h_sigma_ieta_ieta_eb, h_sigma_ieta_ieta_eb_mc, "sigma_ieta_ieta_eb.pdf", 20, "#sigma_{i #eta i #eta} in EB", NO_LINE, 0.01, 0, 0.03);
write_plot(h_sigma_ieta_ieta_ee, h_sigma_ieta_ieta_ee_mc, "sigma_ieta_ieta_ee.pdf", 50, "#sigma_{i #eta i #eta} in EB", NO_LINE, 0.03, 0, 0.09);
write_plot(h_he, h_he_mc, "he.pdf", 10, "H / E", NO_LINE, 0.12, 0, 0.14);
write_plot(h_deta, h_deta_mc, "deta.pdf", 20, NO_CHANGE, 0.007, 0.005, -0.018, 0.018);
write_plot(h_dphi, h_dphi_mc, "dphi.pdf", 20, NO_CHANGE, 0.06, 0.03, -0.14, 0.14);
//write_plot(h_track_iso, h_track_iso_mc, "track_iso.pdf", 200);
write_plot(h_ecal_iso, h_ecal_iso_mc, "ecal_iso.pdf", 50, NO_CHANGE, NO_LINE, 0.15, 0, 1);
write_plot(h_hcal_iso, h_hcal_iso_mc, "hcal_iso.pdf", 50, NO_CHANGE, NO_LINE, 0.1, 0, 0.2);
write_plot(h_1oe_1op, h_1oe_1op_mc, "1oe_1op.pdf", 50, NO_CHANGE, NO_LINE, 0.05, -0.15, 0.15);
write_plot(h_d0, h_d0_mc, "d0.pdf", 400, NO_CHANGE, NO_LINE, 0.02, -0.06, 0.06);
write_plot(h_dz, h_dz_mc, "dz.pdf", 20, NO_CHANGE, NO_LINE, 0.1, -0.3, 0.3);
write_plot(h_iso, h_iso_mc, "iso.pdf", 100, NO_CHANGE, 0.15, 0.10, 0, 0.5);
write_plot(h_nmiss, h_nmiss_mc, "nmiss.pdf", 1, NO_CHANGE, 2, 1, 0, 3);
return EXIT_SUCCESS;
}
int main(int argc, char* argv[]) {
// declarations
struct stat st;
unsigned int nBlocks, i;
block_t *blocks;
struct timespec begin, end;
histogram_t histogram = {0};
char *filename = "war_and_peace.txt";
long num_threads = 1, repetitions=0;
// argument handling
if (argc < 2 || argc > 4) {
printf("usage: %s filename [#threads] [#repetition]\n", argv[0]);
return 1;
}
if (argc >= 2)
filename = argv[1];
if (argc >= 3)
if ((num_threads = strtol(argv[2], NULL, 0)) == 0 || num_threads < 0) {
fprintf(stderr, "#threads not valid!\n");
return 1;
}
if (argc >= 4)
if ((repetitions = strtol(argv[3], NULL, 0)) == 0 || repetitions < 0) {
fprintf(stderr, "#repetition not valid!\n");
return 1;
}
printf("\nProcess %s by %ld thread(s) with %ld repetition(s)\n\n",
filename, num_threads, repetitions);
// get file size and allocate array
stat(filename, &st);
nBlocks = st.st_size / BLOCKSIZE;
nBlocks += (st.st_size % BLOCKSIZE) == 0 ? 0 : 1;
blocks = (block_t*)calloc(nBlocks, BLOCKSIZE * (repetitions+1)); //numb of elts alocated is nBlock, size of each elt is blocksize*(rep+1)
// open file and read all blocks
FILE *fp = fopen(filename, "r");
if (fp == NULL) {
fprintf(stderr, "Could not open file %s", filename);
exit(EXIT_FAILURE);
}
if (fread(blocks, BLOCKSIZE, nBlocks, fp) == 0) {
fprintf(stderr, "Could not read from file %s", filename);
exit(EXIT_FAILURE);
}
// [optional] do the repetition
for (i = 1; i < repetitions; i++)
memcpy(blocks + i*nBlocks, blocks, nBlocks*BLOCKSIZE);
// build the histogram
clock_gettime(CLOCK_MONOTONIC, &begin);
get_histogram(nBlocks*(repetitions+1), blocks, histogram, num_threads);
clock_gettime(CLOCK_MONOTONIC, &end);
free(blocks);
print_histogram(histogram);
printf("\n\nTime: %.5f seconds\n", ((double)end.tv_sec + 1.0e-9*end.tv_nsec) -
((double)begin.tv_sec + 1.0e-9*begin.tv_nsec));
return 0;
}
static GstFlowReturn
kms_pointer_detector_transform_frame_ip (GstVideoFilter * filter,
GstVideoFrame * frame)
{
KmsPointerDetector *pointerdetector = KMS_POINTER_DETECTOR (filter);
GstMapInfo info;
double min_Bhattacharyya = 1.0, bhattacharyya = 1, bhattacharyya2 =
1, bhattacharyya3 = 1;
int i = 0;
pointerdetector->frameSize = cvSize (frame->info.width, frame->info.height);
kms_pointer_detector_initialize_images (pointerdetector, frame);
gst_buffer_map (frame->buffer, &info, GST_MAP_READ);
pointerdetector->cvImage->imageData = (char *) info.data;
if ((pointerdetector->iteration > FRAMES_TO_RESET)
&& (pointerdetector->state != CAPTURING_SECOND_HIST)) {
get_histogram (pointerdetector->cvImage, pointerdetector->upCornerRect1,
pointerdetector->trackinRectSize, pointerdetector->histSetUpRef);
pointerdetector->histRefCapturesCounter = 0;
pointerdetector->secondHistCapturesCounter = 0;
pointerdetector->state = CAPTURING_REF_HIST;
pointerdetector->colorRect1 = WHITE;
pointerdetector->colorRect2 = WHITE;
pointerdetector->iteration = 6;
}
if (pointerdetector->iteration == 5) {
get_histogram (pointerdetector->cvImage, pointerdetector->upCornerRect1,
pointerdetector->trackinRectSize, pointerdetector->histSetUpRef);
pointerdetector->state = CAPTURING_REF_HIST;
goto end;
}
if (pointerdetector->iteration < 6)
goto end;
get_histogram (pointerdetector->cvImage, pointerdetector->upCornerRect1,
pointerdetector->trackinRectSize, pointerdetector->histSetUp1);
bhattacharyya2 =
cvCompareHist (pointerdetector->histSetUp1,
pointerdetector->histSetUpRef, CV_COMP_BHATTACHARYYA);
if ((bhattacharyya2 >= COMPARE_THRESH_SECOND_HIST)
&& (pointerdetector->state == CAPTURING_REF_HIST)) {
pointerdetector->histRefCapturesCounter++;
if (pointerdetector->histRefCapturesCounter > 20) {
pointerdetector->histRefCapturesCounter = 0;
pointerdetector->colorRect1 = CV_RGB (0, 255, 0);
pointerdetector->state = CAPTURING_SECOND_HIST;
}
}
if (pointerdetector->state == CAPTURING_SECOND_HIST) {
get_histogram (pointerdetector->cvImage, pointerdetector->upCornerRect2,
pointerdetector->trackinRectSize, pointerdetector->histSetUp2);
bhattacharyya3 =
cvCompareHist (pointerdetector->histSetUp1,
pointerdetector->histSetUp2, CV_COMP_BHATTACHARYYA);
if (bhattacharyya3 < COMPARE_THRESH_2_RECT) {
pointerdetector->secondHistCapturesCounter++;
if (pointerdetector->secondHistCapturesCounter > 15) {
pointerdetector->secondHistCapturesCounter = 0;
pointerdetector->state = BOTH_HIST_SIMILAR;
pointerdetector->colorRect2 = CV_RGB (0, 255, 0);
cvCopyHist (pointerdetector->histSetUp2, &pointerdetector->histModel);
pointerdetector->upCornerFinalRect.x = 10;
pointerdetector->upCornerFinalRect.y = 10;
pointerdetector->histRefCapturesCounter = 0;
pointerdetector->secondHistCapturesCounter = 0;
}
}
}
for (i = 0; i < pointerdetector->numOfRegions; i++) {
int horizOffset =
pointerdetector->upCornerFinalRect.x +
pointerdetector->windowScale * (rand () %
pointerdetector->trackinRectSize.width -
pointerdetector->trackinRectSize.width / 2);
int vertOffset =
pointerdetector->upCornerFinalRect.y +
pointerdetector->windowScale * (rand () %
pointerdetector->trackinRectSize.height -
pointerdetector->trackinRectSize.height / 2);
pointerdetector->trackingPoint1Aux.x = horizOffset;
pointerdetector->trackingPoint1Aux.y = vertOffset;
pointerdetector->trackingPoint2Aux.x =
horizOffset + pointerdetector->trackinRectSize.width;
pointerdetector->trackingPoint2Aux.y =
vertOffset + pointerdetector->trackinRectSize.height;
if ((horizOffset > 0)
&& (pointerdetector->trackingPoint2Aux.x <
pointerdetector->cvImage->width)
&& (vertOffset > 0)
&& (pointerdetector->trackingPoint2Aux.y <
pointerdetector->cvImage->height)) {
if (pointerdetector->show_debug_info)
cvRectangle (pointerdetector->cvImage,
pointerdetector->trackingPoint1Aux,
pointerdetector->trackingPoint2Aux, CV_RGB (0, 255, 0), 1, 8, 0);
cvSetImageROI (pointerdetector->cvImage,
cvRect (pointerdetector->trackingPoint1Aux.x,
pointerdetector->trackingPoint1Aux.y,
pointerdetector->trackinRectSize.width,
pointerdetector->trackinRectSize.height));
cvCopy (pointerdetector->cvImage, pointerdetector->cvImageAux1, 0);
cvResetImageROI (pointerdetector->cvImage);
calc_histogram (pointerdetector->cvImageAux1,
pointerdetector->histCompare);
bhattacharyya =
cvCompareHist (pointerdetector->histModel,
pointerdetector->histCompare, CV_COMP_BHATTACHARYYA);
if ((bhattacharyya < min_Bhattacharyya)
&& (bhattacharyya < COMPARE_THRESH_HIST_REF)) {
min_Bhattacharyya = bhattacharyya;
pointerdetector->trackingPoint1 = pointerdetector->trackingPoint1Aux;
pointerdetector->trackingPoint2 = pointerdetector->trackingPoint2Aux;
}
}
}
cvRectangle (pointerdetector->cvImage, pointerdetector->upCornerRect1,
pointerdetector->downCornerRect1, pointerdetector->colorRect1, 1, 8, 0);
cvRectangle (pointerdetector->cvImage, pointerdetector->upCornerRect2,
pointerdetector->downCornerRect2, pointerdetector->colorRect2, 1, 8, 0);
if (min_Bhattacharyya < 0.95) {
pointerdetector->windowScale = pointerdetector->windowScaleRef;
} else {
pointerdetector->windowScale = pointerdetector->cvImage->width / 8;
}
CvPoint finalPointerPositionAux;
finalPointerPositionAux.x = pointerdetector->upCornerFinalRect.x +
pointerdetector->trackinRectSize.width / 2;
finalPointerPositionAux.y = pointerdetector->upCornerFinalRect.y +
pointerdetector->trackinRectSize.height / 2;
if (abs (pointerdetector->finalPointerPosition.x -
finalPointerPositionAux.x) < 55 ||
abs (pointerdetector->finalPointerPosition.y -
finalPointerPositionAux.y) < 55) {
finalPointerPositionAux.x =
(finalPointerPositionAux.x +
pointerdetector->finalPointerPosition.x) / 2;
finalPointerPositionAux.y =
(finalPointerPositionAux.y +
pointerdetector->finalPointerPosition.y) / 2;
}
pointerdetector->upCornerFinalRect = pointerdetector->trackingPoint1;
pointerdetector->downCornerFinalRect = pointerdetector->trackingPoint2;
pointerdetector->finalPointerPosition.x = finalPointerPositionAux.x;
pointerdetector->finalPointerPosition.y = finalPointerPositionAux.y;
cvCircle (pointerdetector->cvImage, pointerdetector->finalPointerPosition,
10.0, WHITE, -1, 8, 0);
kms_pointer_detector_check_pointer_position (pointerdetector);
end:
pointerdetector->iteration++;
gst_buffer_unmap (frame->buffer, &info);
return GST_FLOW_OK;
}