Beispiel #1
0
void intersect(const Ty* X1, const Ty* X2, Ty* M, int d, int n1, int n2)
{
    // compute the respective sums
    Ty* hs1 = new Ty[n1];
    Ty* hs2 = new Ty[n2];    
    column_sum(X1, d, n1, hs1);
    column_sum(X2, d, n2, hs2);
    
    // compute metrics
    const Ty* v2 = X2;
    for (int j = 0; j < n2; ++j, v2 += d)
    {
        const Ty* v1 = X1;
        for (int i = 0; i < n1; ++i, v1 += d)
        {
            Ty s = 0;
            
            for (int k = 0; k < d; ++k)
            {
                Ty u1 = v1[k];
                Ty u2 = v2[k];
                s += ((u1 < u2) ? u1 : u2);
            }
            
            Ty smax = ((hs1[i] > hs2[j]) ? hs1[i] : hs2[j]);
            
            *M++ = ((smax > 0) ? s / smax : 1);
        }
    }
    
    // release resources
    delete[] hs1;
    delete[] hs2;
}
Beispiel #2
0
void base_reg::base_score(const mematrix<double>& resid,
                          const int model,
                          const int interaction,
                          const int ngpreds,
                          const masked_matrix& invvarmatrix,
                          const int nullmodel) {
    mematrix<double> oX = reg_data.extract_genotypes();
    mematrix<double> X = apply_model(oX, model, interaction, ngpreds,
            reg_data.is_interaction_excluded, false, nullmodel);
    beta.reinit(X.ncol, 1);
    sebeta.reinit(X.ncol, 1);
    int length_beta = X.ncol;
    double N = static_cast<double>(resid.nrow);
    mematrix<double> tX = transpose(X);
    if (invvarmatrix.length_of_mask != 0){
        tX = tX * invvarmatrix.masked_data;
    }

    mematrix<double> u = tX * resid;
    mematrix<double> v = tX * X;
    mematrix<double> csum = column_sum(X);
    csum = transpose(csum) * csum;
    csum = csum * (1. / N);
    v = v - csum;
    // use cholesky to invert

    LDLT <MatrixXd> Ch = LDLT < MatrixXd > (v.data.selfadjointView<Lower>());
    // before was
    // mematrix<double> v_i = invert(v);
    beta.data = Ch.solve(v.data.adjoint() * u.data);
    //TODO(maartenk): set size of v_i directly or remove mematrix class
    mematrix<double> v_i = v;
    v_i.data = Ch.solve(MatrixXd(length_beta, length_beta).
                                    Identity(length_beta, length_beta));

    double sr = 0.;
    double srr = 0.;
    for (int i = 0; i < resid.nrow; i++)
    {
        sr += resid[i];
        srr += resid[i] * resid[i];
    }
    double mean_r = sr / N;
    double sigma2_internal = (srr - N * mean_r * mean_r) / (N - beta.nrow);
    for (int i = 0; i < beta.nrow; i++)
        sebeta[i] = sqrt(v_i.get(i, i) * sigma2_internal);

    mematrix<double> chi2 = transpose(u) * v_i * u;
    chi2 = chi2 * (1. / sigma2_internal);
    chi2_score = chi2[0];
}
Beispiel #3
0
void base_reg::base_score(mematrix<double>& resid, regdata& rdata, int verbose,
                          double tol_chol, int model, int interaction,
                          int ngpreds, const masked_matrix& invvarmatrix,
                          int nullmodel)
{
    mematrix<double> oX = rdata.extract_genotypes();
    mematrix<double> X = apply_model(oX, model, interaction, ngpreds,
                                     rdata.is_interaction_excluded, false,
                                     nullmodel);
    beta.reinit(X.ncol, 1);
    sebeta.reinit(X.ncol, 1);
    double N = static_cast<double>(resid.nrow);
    mematrix<double> tX = transpose(X);
    if (invvarmatrix.length_of_mask != 0)
        tX = tX * invvarmatrix.masked_data;

    mematrix<double> u = tX * resid;
    mematrix<double> v = tX * X;
    mematrix<double> csum = column_sum(X);
    csum = transpose(csum) * csum;
    csum = csum * (1. / N);
    v = v - csum;
    // use cholesky to invert
    mematrix<double> v_i = v;
    cholesky2_mm(v_i, tol_chol);
    chinv2_mm(v_i);
    // before was
    // mematrix<double> v_i = invert(v);
    beta = v_i * u;
    double sr = 0.;
    double srr = 0.;
    for (int i = 0; i < resid.nrow; i++)
    {
        sr += resid[i];
        srr += resid[i] * resid[i];
    }
    double mean_r = sr / N;
    double sigma2_internal = (srr - N * mean_r * mean_r) / (N - beta.nrow);
    for (int i = 0; i < beta.nrow; i++)
        sebeta[i] = sqrt(v_i.get(i, i) * sigma2_internal);

    mematrix<double> chi2 = transpose(u) * v_i * u;
    chi2 = chi2 * (1. / sigma2_internal);
    chi2_score = chi2[0];
}
/* Calibration run.  Aborting allowed at "safe" points where the scanner won't
 * be left in a crap state. */
int sanei_canon_pp_calibrate(scanner_parameters *sp, char *cal_file) 
{
	int count, readnum, colournum, scanlinenum;
	int outfile;

	int scanline_size;

	int scanline_count = 6;
	/* Don't change this unless you also want to change do_adjust */
	const int calibration_reads = 3;

	unsigned char command_buffer[10];

	image_segment image;
	unsigned char *databuf;

	char colours[3][6] = {"Red", "Green", "Blue"};

	/* Calibration data is monochromatic (greyscale format) */
	scanline_size = sp->scanheadwidth * 1.25;

	/* 620P has to be difficult here... */
	if (!(sp->type) ) scanline_count = 8;

	/* Probably shouldn't have to abort *just* yet, but may as well check */
	if (sp->abort_now) return -1;

	DBG(40, "Calibrating %ix%i pixels calibration image "
			"(%i bytes each scan).\n", 
			sp->scanheadwidth, scanline_count, 
			scanline_size * scanline_count);

	/* Allocate memory for calibration data */	
	sp->blackweight = (unsigned long *)
		calloc(sizeof(unsigned long), sp->scanheadwidth);
	sp->redweight = (unsigned long *)
		calloc(sizeof(unsigned long), sp->scanheadwidth);
	sp->greenweight = (unsigned long *)
		calloc(sizeof(unsigned long), sp->scanheadwidth);
	sp->blueweight = (unsigned long *)
		calloc(sizeof(unsigned long), sp->scanheadwidth);

	/* The data buffer needs to hold a number of images (calibration_reads)
	 * per colour, each sp->scanheadwidth x scanline_count */
	databuf = malloc(scanline_size * scanline_count * calibration_reads*3);

	/* And allocate space for converted image data in this image_segment */
	image.image_data = malloc(scanline_count * sp->scanheadwidth * 2 * 
			calibration_reads);
	image.width = sp->scanheadwidth;
	image.height = scanline_count * calibration_reads;

	/* Sending the "dark calibration" command */
	memcpy(command_buffer, cmd_calblack, 10);

	/* Which includes the size of data we expect the scanner to return */
	command_buffer[7] = ((scanline_size * scanline_count) & 0xff00) >> 8;
	command_buffer[8] = (scanline_size * scanline_count) & 0xff;

	DBG(40, "Step 1/3: Calibrating black level...\n");
	for (readnum = 0; readnum < calibration_reads; readnum++)
	{
		DBG(40, "  * Black scan number %d/%d.\n", readnum + 1, 
				calibration_reads);

		if (sp->abort_now) return -1;

		if (send_command(sp->port, command_buffer, 10, 100000, 5000000))
		{
			DBG(1, "Error reading black level!\n");
			free (image.image_data);
			free(databuf);
			return -1;
			
		}

		/* Black reference data */
		sanei_canon_pp_read(sp->port, scanline_size * scanline_count,
				databuf + 
				(readnum * scanline_size * scanline_count));
	}

	/* Convert scanner format to a greyscale 16bpp image */
	for (scanlinenum = 0; 
			scanlinenum < scanline_count * calibration_reads; 
			scanlinenum++)
	{
		convdata(databuf + (scanlinenum * scanline_size), 
				image.image_data + 
				(scanlinenum * sp->scanheadwidth*2), 
				sp->scanheadwidth, 1);
	}

	/* Take column totals */
	for (count = 0; count < sp->scanheadwidth; count++)
	{
		/* Value is normalised as if we took 6 scanlines, even if we 
		 * didn't (620P I'm looking at you!) */
		sp->blackweight[count] = (column_sum(&image, count) * 6) 
			/ scanline_count >> 6;
	}

	/* 620P has to be difficult here... */
	if (!(sp->type) )
	{
		scanline_count = 6;
		image.height = scanline_count * calibration_reads;
	}

	DBG(40, "Step 2/3: Gamma tables...\n");
	DBG(40, "  * Requesting creation of new of gamma tables...\n");
	if (sp->abort_now) return -1;
	if (send_command(sp->port, cmd_cleargamma, 10, 100000, 5000000))
	{
		DBG(1,"Error sending gamma command!\n");
		free (image.image_data);
		free(databuf);
		return -1;
	}

	DBG(20, "  * Snoozing for 15 seconds while the scanner calibrates...");
	usleep(15000000);
	DBG(40, "done.\n");
	
	DBG(40, "  * Requesting gamma table values...");
	if (send_command(sp->port, cmd_readgamma, 10, 100000, 10000000))
	{
		DBG(1,"Error sending gamma table request!\n");
		free (image.image_data);
		free(databuf);
		return -1;
	}
	DBG(40, "done.\n");

	DBG(40, "  * Reading white-balance/gamma data... ");
	sanei_canon_pp_read(sp->port, 32, sp->gamma);
	DBG(40, "done.\n");

	if (sp->abort_now) return -1;

	memcpy(command_buffer, cmd_calcolour, 10);

	/* Set up returned data size */
	command_buffer[7] = ((scanline_size * scanline_count) & 0xff00) >> 8;
	command_buffer[8] = (scanline_size * scanline_count) & 0xff;

	DBG(40, "Step 3/3: Calibrating sensors...\n");
	/* Now for the RGB high-points */
	for (colournum = 1; colournum < 4; colournum++)
	{
		/* Set the colour we want to read */
		command_buffer[3] = colournum;
		for (readnum = 0; readnum < 3; readnum++)
		{
			DBG(10, "  * %s sensors, scan number %d/%d.\n", 
					colours[colournum-1], readnum + 1,
					calibration_reads);

			if (sp->abort_now) return -1;
			if (send_command(sp->port, command_buffer, 10,
						100000, 5000000))
			{
				DBG(1,"Error sending scan request!");
				free (image.image_data);
				free(databuf);
				return -1;
			}

			sanei_canon_pp_read(sp->port, scanline_size * 
					scanline_count, databuf + 
					(readnum * scanline_size * 
					 scanline_count));

		}

		/* Convert colour data from scanner format to RGB data */
		for (scanlinenum = 0; scanlinenum < scanline_count * 
				calibration_reads; scanlinenum++)
		{
			convdata(databuf + (scanlinenum * scanline_size), 
					image.image_data + 
					(scanlinenum * sp->scanheadwidth * 2), 
					sp->scanheadwidth, 1);
		}

		/* Sum each column of the image and store the results in sp */
		for (count = 0; count < sp->scanheadwidth; count++)
		{
			if (colournum == 1)
				sp->redweight[count] = 
					column_sum(&image, count) >> 6;	
			else if (colournum == 2)
				sp->greenweight[count] = 
					column_sum(&image, count) >> 6;	
			else
				sp->blueweight[count] = 
					column_sum(&image, count) >> 6;	
		}