示例#1
1
文件: wind.c 项目: blaquee/WindowsD
static int update_file(WCHAR *fullpath, WCHAR *name, int res)
{
	DWORD sz;
	WCHAR tmp[PATH_MAX];
	HANDLE f;
	int needmove = 0;
	int elen, len, ret = 0;
	void *ebuf, *buf;

	DBG("updating file %S, rsrc=%d", name, res);
       
	if (res < 0) {
		if (!GetModuleFileName(NULL, tmp, PATH_MAX))
			return 0;
		DBG("got self %S",tmp);
		buf = read_file(tmp, &len);
	} else buf = get_res(res, &len);

	if (!buf) {
		DBG("failed to get update buffer data");
		return 0;
	}

	wcscpy(fullpath + GetSystemDirectory(fullpath, PATH_MAX), name);
	sz = GetFileSize(fullpath, NULL);
	DBG("got fullpath %S", fullpath);

	ebuf = read_file(fullpath, &elen);
	if (ebuf) {
		if ((elen == len) && (!memcmp(ebuf, buf, len))) {
			ret = 1;
			DBG("files equal, skip");
			goto out;
		}
		DBG("file nonequal? %d %d", elen,len);
	}

	f = CreateFile(fullpath, FILE_WRITE_DATA,
		FILE_SHARE_READ, 0, CREATE_ALWAYS, 0, 0);
	DBG("create %p",f);
	if (f == INVALID_HANDLE_VALUE) {
		swprintf(tmp, PATH_MAX, L"%s.new", fullpath);
		f = CreateFile(tmp, FILE_WRITE_DATA,
			FILE_SHARE_READ, 0, CREATE_ALWAYS, 0, 0);
		if (f == INVALID_HANDLE_VALUE)
			goto out;
		needmove = 1;
	}

	sz = 0;
	ret = WriteFile(f, buf, len, &sz, NULL);
	CloseHandle(f);
	if (!ret || sz != len) {
		DeleteFile(needmove?tmp:fullpath);
		goto out;
	}
	if (needmove) {
		DBG("Will move from %S to %S on next boot", tmp, fullpath);
		ret = MoveFileEx(tmp, fullpath, MOVEFILE_DELAY_UNTIL_REBOOT|MOVEFILE_REPLACE_EXISTING);
		if (!ret) DeleteFile(tmp);
	}
	DBG("ret done %d",ret);
out:;
    	if (ebuf)
		free(ebuf);
	if (res < 0)
		free(buf);
	return ret;
}
示例#2
0
文件: a.hpp 项目: Aharobot/m19404
std::vector<Rect> get_textlike_regions(const std::vector<std::vector<Rgb> > &raw) {
    res.clear();
    if (raw.empty()) return res;
    w = raw[0].size();
    h = raw.size();
    calc_lums(raw);
    count_neis();
    build_b();
    get_res();
    return res;
}
示例#3
0
static inline void free_result(value v_res)
{
  PGresult *res;
  np_decr_refcount(get_res_cb(v_res));
  set_res_cb(v_res, NULL);
  res = get_res(v_res);
  if (res) {
    set_res(v_res, NULL);
    PQclear(res);
  }
}
示例#4
0
CAMLprim value PQgetvalue_stub(value v_res, value v_tup_num, value v_field_num)
{
  CAMLparam1(v_res);
  value v_str;
  PGresult *res = get_res(v_res);
  size_t field_num = Long_val(v_field_num);
  size_t tup_num = Long_val(v_tup_num);
  char *str = PQgetvalue(res, tup_num, field_num);
  if (PQfformat(res, field_num) == 0) v_str = make_string(str);
  else {
    /* Assume binary format! */
    size_t len = PQgetlength(res, tup_num, field_num);
    v_str = len ? caml_alloc_string(len) : v_empty_string;
    memcpy(String_val(v_str), str, len);
  }
  CAMLreturn(v_str);
}
示例#5
0
CAMLprim value PQgetescval_stub(value v_res, value v_tup_num, value v_field_num)
{
  CAMLparam1(v_res);
  value v_str;
  PGresult *res = get_res(v_res);
  size_t field_num = Long_val(v_field_num);
  size_t tup_num = Long_val(v_tup_num);
  char *str = PQgetvalue(res, tup_num, field_num);
  if (PQfformat(res, field_num) == 0) {
    if (str != NULL && str[0] == '\\' && str[1] == 'x')
      v_str = unescape_bytea_9x(str + 2);
    else v_str = unescape_bytea(str);
  } else {
    /* Assume binary format! */
    size_t len = PQgetlength(res, tup_num, field_num);
    v_str = len ? caml_alloc_string(len) : v_empty_string;
    memcpy(String_val(v_str), str, len);
  }
  CAMLreturn(v_str);
}
示例#6
0
int main(int argc, char *argv[])
{
    if (argc!=5)
        fatal_err(usage);
    
    double a=conv_segmend(argv[1]);
    double b=conv_segmend(argv[2]);
    if (b<a)
        fatal_err(order);
    
    long int total_segnum=conv_segnum(argv[3]);
    int calcnum=conv_calcnum(argv[4]);
    
    int brdsockfd=init_brd_socket();
    calcmsg_t *calcs=detect_calcs(brdsockfd, &calcnum);
    close(brdsockfd);
    int *confds=distr_task(a, b, total_segnum, calcnum, calcs);
    double res=get_res(calcnum, confds);
    
    printf("%lf\n", res);

    return 0;
}
示例#7
0
int connect_tcpu(struct socket *sock, struct sockaddr_in *servaddr, 
		 int addrlen)
{
    struct tcpcb *tp;
    int error, res, timer;
    struct timeval timeout;
    struct sockaddr_in *laddr = (struct sockaddr_in *)(&sock->laddr);
    
    if((tp = GET_TCPCB(sock)) == NULL)
	return(-1);

    if (sock->state != SS_BOUND)
    {
	printf("tcp_connect: socket is not in bound state (%d != %d)\n",
		sock->state, SS_BOUND);
	return -1;
    }
    
    tcp_stack(tp,(struct sockaddr_in *)(&sock->laddr),servaddr);

    *(struct sockaddr_in *)(&tp->sock->raddr) = *servaddr;

/* Save the client and server addresses in the template, minimizing
   work when sending a packet to the server */
    
    tp->t_template->ti_dst.s_addr = servaddr->sin_addr.s_addr;
    tp->t_template->ti_dport = servaddr->sin_port;
    
    tp->t_template->ti_src.s_addr = laddr->sin_addr.s_addr;
    tp->t_template->ti_sport = laddr->sin_port;
  
/*
    tcpstat.tcps_connattempt++;
*/
    tp->t_template->ti_pr=IP_PROTO_TCP;
    tp->t_state                 = TCPS_SYN_SENT;
    tp->t_timer[TCPT_KEEP]      = TCPTV_KEEP_INIT;
    tp->iss                     = (tcp_seq) NOW();
    tcpu_sendseqinit(tp);

    if((error = tcpu_output(&tp)) < 0)
	return(-1);

  connect:
    timeout.tv_sec = 0;
    timeout.tv_usec = SLOW_TIMO;
    res=get_res(tp,&timeout);
    switch(res) 
    {
	case EVENT_ERROR: return(-1);
	case EVENT_TIMER: {
	    if((timer = slow_timo(tp->sock)) <= TCPT_NTIMERS)
		tcpu_timers(tp, timer);
	    else
		goto connect;  
	    break;
	}
	default:{
	    tcpu_input(&tp,res);
	    if(tp->t_state == TCPS_ESTABLISHED) {
			    CONNECTED(sock) = 1;
			    sock->state = SS_CONNECTED;
                            printf ("\n\nconnect_tcpu: good return\n\n\n");
			    return(1);
		}
	}
    }
    if((tp->t_state == TCPS_SYN_RECEIVED) || (tp->t_state == TCPS_SYN_SENT )) {
	goto connect;
    }
    
    
    printf ("connect_tcpu: bad return\n");
    PAUSE(TENTHS(1));
    return(-1); 
}
示例#8
0
int get_parent_pixels(int pix_c, int pix_p[], char scheme){
  int m,n,res,base_pix,i,j;
  unsigned long pixp;
  //double res_d;

  if(pix_c<0){
    fprintf(stderr, "error in get_parent_pixels: %d is not a valid pixel number\n",pix_c);
    return(1);
  }

  res=get_res(pix_c, scheme);
  if(res==-1) return (1);

  if(scheme=='s'){
    // this scheme divides up the sphere by rectangles in az and el, and is numbered 
    // such that the resolution is encoded in each pixel number.  The whole sky is pixel 0,
    // pixels 1, 2, 3, and 4 are each 1/4 of the sky (resolution 1), pixels 5-20 are each 
    // 1/16 of the sky (resolution 2), etc.
    
    base_pix=pix_c-pixel_start(res,scheme);
    m=base_pix % (int)(pow(2,res));
    n=(base_pix-m)/pow(2,res);

    for(i=res;i>=0;i--){
      //put pixel number into array
      pix_p[i]=pixel_start(i,scheme)+(int)(pow(2,i))*n+m;
      //make child pixel into next parent pixel
      n=n/2;
      m=m/2;
    }
    return(0);
  }
  else if(scheme=='d'){
    assign_parameters();
    //printf("res = %d\n", res);
    //printf("res1 (1) = %d\n", res1);
    //if (res >= 1) { 
    //  res_d = (double)(log((double)res)/log(2.0))+1;
    //  res1 = (int)(res_d + 0.1);
    //}
    //printf("res1 (2) = %d\n", res1);
    pix_p[res]=pix_c;
    for(i=res;i>2;i--){
      //printf("args to superpix: %d, %d, %d\n", (int)pow(2,i-1), pix_p[i]-pixel_start(i, scheme), (int)pow(2,i-2));
      superpix((int)pow(2,i-2), (unsigned long)pix_p[i]-(unsigned long)pixel_start(i, scheme), (int)pow(2,i-3), &pixp);
      //printf("pixp = %d\n", (int)pixp);
      pix_p[i-1] = (int)pixp + pixel_start(i-1, scheme);
    }
    for(j=0;j<=5;j++){
      for(i=118+j*72;i<=152+j*72;i+=2){
	if(pix_p[2]==i || pix_p[2]==i+1 || pix_p[2]==i+36 || pix_p[2]==i+37) pix_p[1]=(i-118-j*36)/2+1;
      }
    }
    for(i=550;i<=585;i++){
      if(pix_p[2]==i) {
	pix_p[1]=(i-114)/4;
      }
    }
    pix_p[0]=0;
    return(0);
  }
  else{
    fprintf(stderr, "error in get_parent_pixels: pixel scheme %c not recognized.\n", scheme);
    return(1);   
  }
}
示例#9
0
文件: pixelize.c 项目: bareid/mangle
int pixel_loop(int pix, int n, polygon *input[/*n*/], int out_max, polygon *output[/*out_max*/]){
  int *child_pix,children;
  int i,j,k,m,out,nout;
  int ier, iprune, np;
  polygon *pixel;
  polygon **poly;
 
  //allocate memory for work array of polygon pointers
  poly=(polygon **) malloc(sizeof(polygon *) * n);
  if(!poly){
    fprintf(stderr, "pixel_loop: failed to allocate memory for %d polygon pointers\n",n);
    return(-1);
  }
  
  // allocate memory for child_pix array
  if(pix==0 && scheme=='d'){
    child_pix=(int *) malloc(sizeof(int) * 117);
    children=117;
    if(!child_pix){
      fprintf(stderr, "pixel_loop: failed to allocate memory for 117 integers\n");
      return(-1);
    }
  }
  else{
    child_pix=(int *) malloc(sizeof(int) * 4);
    children=4;
    if(!child_pix){
      fprintf(stderr, "pixel_loop: failed to allocate memory for %d integers\n", 4);
      return(-1);
    }
  }

  get_child_pixels(pix, child_pix, scheme);
  out=0;
  
  for(i=0;i<children;i++){    
    /*get the current child pixel*/
    pixel=get_pixel(child_pix[i], scheme);
 
    if(!pixel){
      fprintf(stderr, "error in pixel_loop: could not get pixel %d\n", child_pix[i]); 
      return(-1);
    }
    
    /*loop through input polygons to find the ones that overlap with current child pixel*/
    for(j=0;j<n;j++){
      /* skip null polygons */
      if (input[j]->np > 0 && input[j]->cm[0] == 0.){
	poly[j] = 0x0;
	continue;
      }

      np=input[j]->np+pixel->np;
      poly[j]=new_poly(np);
      if(!poly[j]){
	fprintf(stderr, "error in pixel_loop: failed to allocate memory for polygon of %d caps\n", np);
	return(-1);
      }
      /*set poly[j] to the intersection of input[j] and current child pixel*/
      poly_poly(input[j],pixel,poly[j]);
      poly[j]->pixel=pixel->pixel;
    
      iprune = prune_poly(poly[j], mtol);
      if (iprune == -1) {
	fprintf(stderr, "pixelize: failed to prune polygon for pixel %d; continuing ...\n", poly[j]->pixel);
	//return(-1);
      }
      /*if polygon is null, get rid of it*/
      if (iprune >= 2) {
	free_poly(poly[j]);
	poly[j] = 0x0;
      }       
    }
    
    /*copy down non-null polygons*/
    k=0;
    for(j=0;j<n;j++){
      if(poly[j]){
	poly[k++]=poly[j];
      }
    }
    m=k;
    /*nullify the rest of the array, but don't free, since pointers have been copied above*/
    for(j=m;j<n;j++){
      poly[j]=0x0;
    }
    
    /*if we're below the max resolution, recursively call pixel_loop on the current child pixel */ 
    if(m>polys_per_pixel && get_res(child_pix[i],scheme)<res_max){
      //printf("calling pixel loop for pixel %d with %d polygons\n",child_pix[i],m);
      nout=pixel_loop(child_pix[i],m,poly,out_max-out,&output[out]);
      if(nout==-1) return(-1);
      out+=nout;
    }
    else{
      for(k=0;k<m;k++){
	/* check whether exceeded maximum number of polygons */
	if (out >= out_max) {
	  fprintf(stderr, "pixel_loop: total number of polygons exceeded maximum %d\n", NPOLYSMAX);
	  fprintf(stderr, "if you need more space, enlarge NPOLYSMAX in defines.h, and recompile\n");
	  return(-1);
	}
	/*make sure output polygon has enough room */
	ier = room_poly(&output[out], poly[k]->np, DNP, 0);
	if (ier == -1) {
	  fprintf(stderr, "error in pixel_loop: failed to allocate memory for polygon of %d caps\n", poly[i]->np + DNP);
	  return(-1);
	}

	/*copy polygon to output array*/
	copy_poly(poly[k],output[out]);
	out++;    
      }
    }
    /*free up memory for next child pixel*/
    
    free_poly(pixel);
    for(j=0;j<n;j++){
      free_poly(poly[j]);
    }
  }
  free(child_pix);
  free(poly);
  return out;
}
示例#10
0
文件: polyid.c 项目: abensonca/mangle
/*------------------------------------------------------------------------------
  Id numbers of polygons containing az, el positions.
  The az, el positions are read from in_filename,
  and the results are written to out_filename.
  Implemented as interpretive read/write, to permit interactive behaviour.

   Input: in_filename = name of file to read from;
			"" or "-" means read from standard input.
	  out_filename = name of file to write to;
			"" or "-" means write to standard output.
	  fmt = pointer to format structure.
	  poly = array of pointers to polygons.
	  npoly = number of polygons in poly array.
  Return value: number of lines written,
		or -1 if error occurred.
*/
int poly_ids(char *in_filename, char *out_filename, format *fmt, int npoly, polygon *poly[/*npoly*/])
{
#define AZEL_STR_LEN	32
    char input[] = "input", output[] = "output";
    char *word, *next;
    char az_str[AZEL_STR_LEN], el_str[AZEL_STR_LEN];
    int i, idwidth, ird, len, nid, nids, nid0, nid2, np;
    long long idmin, idmax;
    long long *id;
    long double *weight;
    azel v;
    char *out_fn;
    FILE *outfile;
    int *start;
    int *total;
    int *parent_pixels;
    int p, res, max_pixel, ier, sorted;

    ier=-1;
    sorted=0;
    while(ier!=0){
      max_pixel= poly[npoly-1]->pixel; 
      res_max=get_res(max_pixel, scheme);
      max_pixel=pixel_start(res_max+1,scheme);
      
      /* allocate memory for pixel info arrays start and total */ 
      msg("res_max=%d, max_pixel=%d\n",res_max,max_pixel);
      start = (int *) malloc(sizeof(int) * max_pixel);
      if (!start) {
	fprintf(stderr, "polyid: failed to allocate memory for %d integers\n", max_pixel);
	return(-1);
      }
      total = (int *) malloc(sizeof(int) * max_pixel);
      if (!total) {
	fprintf(stderr, "polyid: failed to allocate memory for %d integers\n", max_pixel);
	return(-1);
      }
      parent_pixels = (int *) malloc(sizeof(int) * (res_max+1));
      if (!parent_pixels) {
	fprintf(stderr, "polyid: failed to allocate memory for %d integers\n", res_max+1);
	return(-1);
      }
      
      /* build lists of starting indices of each pixel and total number of polygons in each pixel*/
      
      ier=pixel_list(npoly, poly, max_pixel, start, total);
      if (ier == -1) {
	// if pixel_list returns an error, try sorting the polygons and trying again
	if(!sorted){
	  msg("sorting polygons...\n");
	  poly_sort(npoly,poly,'p');
	  sorted=1;
	}
	else{
	  fprintf(stderr, "poly_ids: error building pixel index lists\n");
	  return(-1);
	}
      } 
    }
    
    /* open in_filename for reading */
    if (!in_filename || strcmp(in_filename, "-") == 0) {
	file.file = stdin;
	file.name = input;
    } else {
	file.file = fopen(in_filename, "r");
	if (!file.file) {
	    fprintf(stderr, "cannot open %s for reading\n", in_filename);
	    return(-1);
	}
	file.name = in_filename;
    }
    file.line_number = 0;

    /* open out_filename for writing */
    if (!out_filename || strcmp(out_filename, "-") == 0) {
	outfile = stdout;
	out_fn = output;
    } else {
	outfile = fopen(out_filename, "w");
	if (!outfile) {
	    fprintf(stderr, "cannot open %s for writing\n", out_filename);
	    return(-1);
	}
	out_fn = out_filename;
    }

    /* advise angular units */
    msg("will take units of input az, el angles in %s to be ", file.name);
    switch (fmt->inunit) {
#include "angunit.h"
    }
    msg("\n");
    if (fmt->outunit != fmt->inunit) {
	msg("units of output az, el angles will be ");
	switch (fmt->outunit) {
#include "angunit.h"
	}
	msg("\n");
    }

    /* largest width of polygon id number */
    idmin = 0;
    idmax = 0;
    for (i = 0; i < npoly; i++) {
	if (!poly[i]) continue;
	if (poly[i]->id < idmin) idmin = poly[i]->id;
	if (poly[i]->id > idmax) idmax = poly[i]->id;
    }
    idmin = ((idmin < 0)? floorl(log10l((long double)-idmin)) + 2 : 1);
    idmax = ((idmax > 0)? floorl(log10l((long double)idmax)) + 1 : 1);
    idwidth = ((idmin > idmax)? idmin : idmax);

    /* write header */
    v.az = 0.;
    wrangle(v.az, fmt->outunit, fmt->outprecision, AZEL_STR_LEN, az_str);
    len = strlen(az_str);
    if (fmt->outunit == 'h') {
	sprintf(az_str, "az(hms)");
	sprintf(el_str, "el(dms)");
    } else {
	sprintf(az_str, "az(%c)", fmt->outunit);
	sprintf(el_str, "el(%c)", fmt->outunit);
    }
    fprintf(outfile, "%*s %*s", len, az_str, len, el_str);
    if (npoly > 0){
      if(polyid_weight==1){
	fprintf(outfile, " polygon_weights");
      }
      else{
	fprintf(outfile, " polygon_ids");	
      }
    }
    fprintf(outfile, "\n");

    /* interpretive read/write loop */
    np = 0;
    nid = 0;
    nids = 0;
    nid0 = 0;
    nid2 = 0;
    while (1) {
	/* read line */
	ird = rdline(&file);
	/* serious error */
	if (ird == -1) return(-1);
	/* EOF */
	if (ird == 0) break;

	/* read <az> */
	word = file.line;
	ird = rdangle(word, &next, fmt->inunit, &v.az);
	/* skip header */
	if (ird != 1 && np == 0) continue;
	/* otherwise exit on unrecognized characters */
	if (ird != 1) break;

	/* read <el> */
	word = next;
	ird = rdangle(word, &next, fmt->inunit, &v.el);
	/* skip header */
	if (ird != 1 && np == 0) continue;
	/* otherwise exit on unrecognized characters */
	if (ird != 1) break;

	/* convert az and el from input units to radians */
	scale_azel(&v, fmt->inunit, 'r');
	
	//find out what pixel the az el point is in at the maximum resolution
	p=which_pixel(v.az, v.el, res_max, scheme);
	//get the list of all the possible parent pixels
	get_parent_pixels(p, parent_pixels, scheme);

	nid=0;
	for(res=res_max;res>=0;res--){
	  p=parent_pixels[res];
	  //if this pixel isn't in the polygon list, go to next parent pixel
	  if(total[p]==0) continue;
	  // id numbers of the polygons containing position az, el 
	  nid = poly_id(total[p], &poly[start[p]], v.az, v.el, &id, &weight);
	}
	
	/* convert az and el from radians to output units */
	scale_azel(&v, 'r', fmt->outunit);

	/* write result */
	wrangle(v.az, fmt->outunit, fmt->outprecision, AZEL_STR_LEN, az_str);
	wrangle(v.el, fmt->outunit, fmt->outprecision, AZEL_STR_LEN, el_str);
	fprintf(outfile, "%s %s", az_str, el_str);
	for (i = 0; i < nid; i++) {
	  if(polyid_weight==1){
	    fprintf(outfile, " %.18Lg", weight[i]);
	  } else{
	    fprintf(outfile, " %*lld", idwidth, id[i]);
	  }
	}
	fprintf(outfile, "\n");
	fflush(outfile);

        /* increment counters of results */
	np++;
	nids += nid;
	if (nid == 0) {
	  nid0++;
	} else if (nid >= 2) {
	  nid2++;
	}
    }

    /* advise */
    if (nid0 > 0) msg("%d points were not inside any polygon\n", nid0);
    if (nid2 > 0) msg("%d points were inside >= 2 polygons\n", nid2);

    if (outfile != stdout) {
      if(polyid_weight==1){
	msg("polyid: %d weights at %d positions written to %s\n", nids, np, out_fn);
      } else {
	msg("polyid: %d id numbers at %d positions written to %s\n", nids, np, out_fn);
      }
    }
    
    free(start);
    free(total);
    free(parent_pixels);

    return(np);
}
示例#11
0
		bool					sqlite_db::queryScalar(const wstring& s,wstring& scalar)			{if(!query(s) || res_count()==0 || get_res().empty() || !get_res()._res[0].size()) return false; scalar=get_res().getWString(0,0); return true;}
示例#12
0
CAMLprim value PQfnumber_stub(value v_res, value v_field_name)
{
  return Val_long(PQfnumber(get_res(v_res), String_val(v_field_name)));
}
示例#13
0
CAMLprim value PQres_isnull(value v_res)
{
  return Val_bool(get_res(v_res) ? 0 : 1);
}
示例#14
0
/*------------------------------------------------------------------------------
  Take pixelized polygons, find the average weight within each pixel, and return a set of polygons consisting of the pixels weighted with the average weight.

   Input: poly = array of pointers to polygons.
	  npoly = pointer to number of polygons.
  Output: polys = array of pointers to polygons;
  Return value: number of polygons discarded by pixelmapping,
		or -1 if error occurred.
*/
int pixelmap(int *npoly, polygon *poly[/**npoly*/])
{
  int i, j, nadj, k, kstart,kend,numpix;
  int *start;
  int *total;
  int *parent_pixels;
  int begin, end, p,max_pixel,min_pixel, ier, verb,res1,res2;
  long double tol,area, tot_area;
  long double *av_weight;
  long double *av_weight0;

  poly_sort(*npoly,poly,'p');
  min_pixel = poly[0]->pixel; 
  max_pixel = poly[*npoly-1]->pixel+1; 
  res1=get_res(min_pixel,scheme);
  res2=get_res(max_pixel,scheme);

  if(res1<res_max){
    fprintf(stderr,"pixelmap: there are pixels in the mask with a lower resolution than the desired pixelmap resolution %d.  The desired pixelmap resolution can be set with the -P option.\n",res_max);
    fprintf(stderr,"Before using pixelmap, use pixelize with the -P0,r option to pixelize the entire mask to the desired resolution r.\n");
    return(-1);
  }

 
  /* allocate memory for pixel info arrays start and total */ 
  start = (int *) malloc(sizeof(int) * max_pixel);
  if (!start) {
    fprintf(stderr, "pixelmap: failed to allocate memory for %d integers\n", max_pixel);
    return(-1);
  }
  total = (int *) malloc(sizeof(int) * max_pixel);
  if (!total) {
    fprintf(stderr, "pixelmap: failed to allocate memory for %d integers\n", max_pixel);
    return(-1);
  }

  /* build lists of starting indices of each pixel and total number of polygons in each pixel*/
  ier=pixel_list(*npoly, poly, max_pixel, start, total);
  if (ier == -1) {
    fprintf(stderr, "pixelmap: error building pixel index lists\n");
    return(-1);
  } 

  //allocate memory for parent pixels array
  parent_pixels = (int *) malloc(sizeof(int) * (res2+1));
  if (!parent_pixels) {
    fprintf(stderr, "pixelmap: failed to allocate memory for %d integers\n", res2+1);
    return(-1);
  }

  //kstart=number of first pixel at desired output resolution
  //kend=number of last pixel at desired output resolution
  if(res_max==-1){
    kstart=pixel_start(res1,scheme);
    kend=pixel_start(res2+1,scheme)-1;
  }
  else{
    kstart=pixel_start(res_max,scheme);
    kend=pixel_start(res_max+1,scheme)-1;
  }
  av_weight0= (long double *) malloc(sizeof(long double) * (kend-kstart+1) );
  if (!av_weight0) {
    fprintf(stderr, "pixelmap: failed to allocate memory for %d integers\n", kend-kstart+1 );
    return(-1);
  }
  //make av_weight an array indexed by the pixel number 
  av_weight=av_weight0-kstart;

  //set av_weight array to 0 initially
  for(k=kstart;k<=kend;k++){
    av_weight[k]=0;
  }

  nadj = 0;
  verb=1;
   
  /*find average weight of polygons within each pixel*/
  for(p=min_pixel;p<max_pixel;p++){
    begin=start[p];
    end=start[p]+total[p];
    ier=get_parent_pixels(p,parent_pixels,scheme);
    if(ier) return(-1);
    
    //set k to the pixel at the desired output resolution, or to the pixel number if using
    //existing resolution

    k=(res_max==-1) ? p : parent_pixels[res_max];
    
    for (i = begin; i < end; i++) {
      if (!poly[i]) continue;
      tol=mtol;
      ier = garea(poly[i], &tol, verb, &area);
      if(ier==1 || ier == -1){
	fprintf(stderr, "error %d in garea in polygon %d\n", ier, poly[i]->id);
	continue;
      }
      
      av_weight[k]+=poly[i]->weight * area;
    }
  }
  
  //replace polygons in input array with non-zero weight pixels
  j=0;
  for(k=kstart;k<=kend;k++){
    if(av_weight[k]==0) continue;
    free_poly(poly[j]);
    poly[j]=get_pixel(k,scheme);
    tol=mtol;
    ier = garea(poly[j], &tol, verb, &tot_area);
    if(ier==1 || ier == -1){
      fprintf(stderr, "pixelmap: error in garea in pixel %d\n",p);
      continue;
    }
    poly[j]->weight=av_weight[k]/tot_area;
    j++;
    if(j> *npoly ){
      fprintf(stderr,"pixelmap: number of pixels with non-zero weight exceeds number of polygons.\n");
      fprintf(stderr, "Try running unify on your mask to remove zero-weight polygons before using pixelmap.\n");
    }
  }

  numpix=j;
  
  for(j=numpix; j< *npoly; j++){
    free_poly(poly[j]);
    poly[j] = 0x0;
    nadj++;
  }

  *npoly=numpix;

  free(start);
  free(total);
  free(parent_pixels);
  free(av_weight0);
  
  /* assign new polygon id numbers */
  if (fmt.newid == 'n') {
    for (i = 0; i < *npoly; i++) {
      poly[i]->id = i;
    }
  }
  
  if (fmt.newid == 'p') {
    for (i = 0; i < *npoly; i++) {
      poly[i]->id = poly[i]->pixel;
    }
  }
  
  /* advise */
  msg("pixelmap: %d pixels in map\n", numpix);

  return(nadj);
}
	float startGeneticAlgo(void** solvers, float** inputs, float* outputs, int count_row, int count_col, 
		size_t(*get_res)(float* in, float* out, void* solver), void(*set_weights)(float* weights, void* solver),
		int count_weights, int count_person, int count_epochs, int count_bests, float mutation_percent, float* res_weights)
	{

#ifdef GENETIC_DEBUG
		ofstream fout;
		fout.open("Genetic_debug.txt", ios_base::trunc);
		fout << "count_row = " << count_row << endl;
		fout << "count_col = " << count_col << endl;
		fout << "count_weights = " << count_weights << endl;
		fout << "count_person = " << count_person << endl;
		fout << "count_epochs = " << count_epochs << endl;
		fout << "count_bests = " << count_bests << endl;
		fout.close();
#endif // GENETIC_DEBUG


		float** new_weights = (float**)malloc(count_person * sizeof(float*));
#ifdef GENETIC_DEBUG
		fout.open("Genetic_debug.txt", ios::app);
		fout << "Created new_weights" << endl;		
		fout.close();
#endif // GENETIC_DEBUG

		int person_num, epoch_num, best_num, weight_num;
		float* err = (float*)malloc(count_person * sizeof(float));
#ifdef GENETIC_DEBUG
		fout.open("Genetic_debug.txt", ios::app);
		fout << "Created err" << endl;
		fout.close();
#endif // GENETIC_DEBUG

		int* arr_best_nums = (int*)malloc(count_bests * sizeof(int));
#ifdef GENETIC_DEBUG
		fout.open("Genetic_debug.txt", ios::app);
		fout << "Created arr_best_nums" << endl;
		fout.close();
#endif // GENETIC_DEBUG

		int* arr_bad_nums = (int*)malloc(count_bests * sizeof(int));
#ifdef GENETIC_DEBUG
		fout.open("Genetic_debug.txt", ios::app);
		fout << "Created arr_bad_nums" << endl;
		fout.close();
#endif // GENETIC_DEBUG
		float best_err = 0;
		float** tmp_res = (float**)malloc(count_person*sizeof(float*));


		for (person_num = 0; person_num < count_person; person_num++)
		{
			tmp_res[person_num] = (float*)malloc(sizeof(float));
			new_weights[person_num] = (float*)malloc(count_weights * sizeof(float));
			for (weight_num = 0; weight_num < count_weights; weight_num++)
			{
				new_weights[person_num][weight_num] = ((float)rand()) / RAND_MAX;
			}
			set_weights(new_weights[person_num], solvers[person_num]);
		}
		epoch_num = 0;
#ifdef GENETIC_DEBUG
		fout.open("Genetic_debug.txt", ios::app);
		fout << "Created and set new_weights" << endl;
		fout.close();
#endif // GENETIC_DEBUG
		while (epoch_num < count_epochs)
		{
			for (person_num = 0; person_num < count_person; person_num++)
			{
				int row_num;
#ifdef GENETIC_DEBUG
				fout.open("Genetic_debug.txt", ios::app);
				fout << "Strat for person_num =" << person_num << endl;
				fout.close();
#endif // GENETIC_DEBUG
				err[person_num] = 0;
#ifdef GENETIC_DEBUG
				fout.open("Genetic_debug.txt", ios::app);
				fout << "Err =" << err[person_num] << endl;
				fout.close();
#endif // GENETIC_DEBUG
				for (row_num = 0; row_num < count_row; row_num++)
				{
#ifdef GENETIC_DEBUG
					int count_col_tmp = 0;
					fout.open("Genetic_debug.txt", ios::app);
					fout << "Strat get res for row_num =" << row_num << endl;
					for (count_col_tmp = 0; count_col_tmp < count_col; count_col_tmp++)
					{
						fout << "Inputs " << count_col_tmp<<" = "<<inputs[row_num][count_col_tmp] << endl;
					}
					fout.close();
#endif // GENETIC_DEBUG
					get_res( inputs[row_num], tmp_res[person_num],solvers[person_num]);
#ifdef GENETIC_DEBUG
					fout.open("Genetic_debug.txt", ios::app);
					fout << "Finished" << endl;					
					fout.close();
#endif // GENETIC_DEBUG
					err[person_num] += (outputs[row_num] - tmp_res[person_num][0]) * (outputs[row_num] - tmp_res[person_num][0]);
				}
#ifdef GENETIC_DEBUG
				fout.open("Genetic_debug.txt", ios::app);
				fout << "Finished for person_num =" << person_num << endl;
				fout.close();
#endif // GENETIC_DEBUG
				err[person_num] /= count_row;
			}
#ifdef GENETIC_DEBUG
			fout.open("Genetic_debug.txt", ios::app);
			fout << "epoch_num = "<< epoch_num << ", of " << count_epochs << endl;
			for (person_num = 0; person_num < count_person; person_num++)
			{
				fout << "	person_num = " << person_num << ", err = " << err[person_num] << endl;
			}
			fout.close();
#endif // GENETIC_DEBUG
			for (best_num = 0; best_num < count_bests; best_num++)
			{
				int tmp_best_person_num;
				float tmp_best_person_err;
				person_num = 0;
				do
				{
					tmp_best_person_num = person_num;
					tmp_best_person_err = err[person_num];
					person_num++;
				} while (err[tmp_best_person_num] < 0);
				for (; person_num < count_person; person_num++)
				{
					if (tmp_best_person_err > err[person_num] && err[person_num] >= 0)
					{
						tmp_best_person_err = err[person_num];
						tmp_best_person_num = person_num;
					}
				}
				arr_best_nums[best_num] = tmp_best_person_num;
				err[tmp_best_person_num] = -err[tmp_best_person_num];
			}
#ifdef GENETIC_DEBUG
			fout.open("Genetic_debug.txt", ios::app);
			fout << "epoch_num = " << epoch_num << ", of " << count_epochs << endl;
			for (best_num = 0; best_num < count_bests; best_num++)
			{
				fout << "	best_num = " << arr_best_nums[best_num] << ", err = " << -err[arr_best_nums[best_num]] << endl;
			}
			fout.close();
#endif // GENETIC_DEBUG
			best_err = -err[0];
			for (best_num = 0; best_num < count_bests; best_num++)
			{
				int tmp_bad_person_num;
				float tmp_bad_person_err;
				person_num = 0;
				do
				{
					tmp_bad_person_num = person_num;
					tmp_bad_person_err = err[person_num];
					person_num++;
				} while (err[tmp_bad_person_num] < 0 && person_num < count_person);

				for (; person_num < count_person; person_num++)
				{
					if (tmp_bad_person_err < err[person_num])
					{
						tmp_bad_person_err = err[person_num];
						tmp_bad_person_num = person_num;
					}
				}
				arr_bad_nums[best_num] = tmp_bad_person_num;
				err[tmp_bad_person_num] = -err[tmp_bad_person_num];
			}
#ifdef GENETIC_DEBUG
			fout.open("Genetic_debug.txt", ios::app);
			fout << "epoch_num = " << epoch_num << ", of " << count_epochs << endl;
			for (best_num = 0; best_num < count_bests; best_num++)
			{
				fout << "	bad_num = " << arr_bad_nums[best_num] << ", err = " << -err[arr_bad_nums[best_num]] << endl;
			}
			fout.close();
#endif // GENETIC_DEBUG
			for (best_num = 0; best_num < count_bests; best_num += 2)
			{
				int tmp_mask, tmp_l, tmp_r, mut_mask, res_tmp;
				float is_mut;
				for (weight_num = 0; weight_num < count_weights; weight_num++)
				{
					tmp_mask = rand();
					tmp_l = (*((int*)(&(new_weights[arr_best_nums[best_num]])))) & tmp_mask;
					tmp_r = (*((int*)(&(new_weights[arr_best_nums[best_num + 1]])))) & (!tmp_mask);
					res_tmp = (tmp_l | tmp_r);
					new_weights[arr_bad_nums[best_num]][weight_num] = (float)(*((float*)(&res_tmp)));
					is_mut = rand() / RAND_MAX;
					if (is_mut < mutation_percent)
					{
						mut_mask = rand();
						new_weights[arr_bad_nums[best_num]][weight_num] = (float)((*((int*)(&(new_weights[arr_bad_nums[best_num]][weight_num])))) ^ mut_mask);
					}


					tmp_l = (*((int*)(&(new_weights[arr_best_nums[best_num]])))) & (!tmp_mask);
					tmp_r = (*((int*)(&(new_weights[arr_best_nums[best_num + 1]])))) & tmp_mask;
					res_tmp = (tmp_l | tmp_r);
					new_weights[arr_bad_nums[best_num + 1]][weight_num] = (float)(*((float*)(&res_tmp)));
					is_mut = rand() / RAND_MAX;
					if (is_mut < mutation_percent)
					{
						mut_mask = rand();
						new_weights[arr_bad_nums[best_num + 1]][weight_num] = (float)((*((int*)(&(new_weights[arr_bad_nums[best_num + 1]][weight_num])))) ^ mut_mask);
					}

				}
				set_weights(new_weights[arr_bad_nums[best_num]], solvers[arr_bad_nums[best_num]]);
				set_weights(new_weights[arr_bad_nums[best_num + 1]], solvers[arr_bad_nums[best_num + 1]]);
			}

			epoch_num++;
		}

		for (weight_num = 0; weight_num < count_weights; weight_num++)
		{
			res_weights[weight_num] = new_weights[arr_best_nums[0]][weight_num];

		}
#ifdef GENETIC_DEBUG
			fout.open("Genetic_debug.txt", ios::app);
			fout << "Weights values:" << endl;
			for (weight_num = 0; weight_num < count_weights; weight_num++)
			{
				fout <<res_weights[weight_num] << endl;

			}
			fout.close();
#endif // GENETIC_DEBUG
#ifdef GENETIC_DEBUG
		fout.open("Genetic_debug.txt", ios::app);
		fout << "Was set res weights" << endl;
		fout.close();
#endif // GENETIC_DEBUG
		for (person_num = 0; person_num < count_person; person_num++)
		{
			free(new_weights[person_num]);
		}
#ifdef GENETIC_DEBUG
		fout.open("Genetic_debug.txt", ios::app);
		fout << "Remove new weights" << endl;
		fout.close();
#endif // GENETIC_DEBUG
		free(new_weights);
#ifdef GENETIC_DEBUG
		fout.open("Genetic_debug.txt", ios::app);
		fout << "Remove new weights, again" << endl;
		fout.close();
#endif // GENETIC_DEBUG
		free(err);
#ifdef GENETIC_DEBUG
		fout.open("Genetic_debug.txt", ios::app);
		fout << "Remove err" << endl;
		fout.close();
#endif // GENETIC_DEBUG
		free(arr_best_nums);
#ifdef GENETIC_DEBUG
		fout.open("Genetic_debug.txt", ios::app);
		fout << "Remove arr_best_nums" << endl;
		fout.close();
#endif // GENETIC_DEBUG
		free(arr_bad_nums);
#ifdef GENETIC_DEBUG
		fout.open("Genetic_debug.txt", ios::app);
		fout << "Remove arr_bad_nums" << endl;
		fout.close();
#endif // GENETIC_DEBUG
		return best_err;

	}
示例#16
0
 inline string get_current_res(){ return get_res(res_version);}