Example #1
0
		void testCopy() {
			DataKeyDimension dim(*m_dim1);
			CPPUNIT_ASSERT(dim==*m_dim1);
		}
Example #2
0
double & band_matrix::saved_diag(int i)
{
    assert( (i>=0) && (i<dim()) );
    return m_lower[0][i];
}
 const SpdMatrix & IMMGS::Sigma() const {
   sigma_scratch_.resize(dim());
   sigma_scratch_.diag() = unscaled_variance_diagonal();
   sigma_scratch_.diag() *= sigsq();
   return sigma_scratch_;
 }
Example #4
0
int main(int argc, char** argv){// 1000G.marker.gz -> rs pos A1 A2
	op = (char*)calloc(100, sizeof(char));
	if(argc==1){fprintf(stderr,"tabix tbxfile CHR | ./ase 1000G.marker.gz [-printFrag] [-overlap] > output\n"); return -1;}
	
	int i;
	char* buf; buf = (char*)calloc(1000,sizeof(char));
	long printFrag=0;
	long overlap=0;
	//long ascount;
	for(i=0; i<argc; i++){if(strcmp(argv[i],"-printFrag")==0){printFrag=1;}}
	for(i=0; i<argc; i++){if(strcmp(argv[i],"-overlap")==0){overlap=1;}}
	//for(i=0; i<argc; i++){if(strcmp(argv[i],"-ascount")==0){ascount=1;}}
	
	
	long N=0;
	gzFile fmarker;
	
	if((fmarker = gzopen(argv[1], "rb6f"))==NULL){fprintf(stderr, "gzread failed. no file!\n"); return -1;}
	long P=0;
	//N = getLine(fmarker);
	dim(fmarker, &buf, 1000*sizeof(char), &N, &P, 0);
fprintf(stderr,"N of markers: %ld %ld\n", N, P);
	
	char** rs;
	long* pos;
	char* cpos;
	char* A1;
	char* A2;
	long* Y;
	double* ds;
	rs = (char**)calloc(N,sizeof(char*));  for(i=0;i<N;i++){ rs[i]=(char*)calloc(100,sizeof(char)); }
	cpos = (char*)calloc(100,sizeof(char));
	pos = (long*)calloc(N,sizeof(long));
	ds = (double*)calloc(N,sizeof(double));
	A1 = (char*)calloc(N,sizeof(char));
	A2 = (char*)calloc(N,sizeof(char));
	Y = (long*)calloc(N*3,sizeof(long));
	
	for(i=0; i<N; i++){ds[i]=0.0;}
	for(i=0; i<N*3; i++){Y[i]=0;}
	int ret;
	//char* buf;
	int l=0,cl=0,ncol=0;
	//buf = (char*)calloc(1000,sizeof(char));
	while((ret = gzread(fmarker, buf, sizeof(buf))) != 0 && ret!=-1){
		for(i=0;i<ret/sizeof(char);i++){
			if(buf[i]=='\n'){
				l++;
				ncol=cl=0;
			}else if(buf[i]==' ' || buf[i]=='\t' || buf[i]=='\n'){
				if(ncol==2){rs[l][cl]='\0';}else if(ncol==1){cpos[cl]='\0'; pos[l]=atoi(cpos);}
				if(buf[i]=='\n'){l++; ncol=cl=0;}else{cl=0; ncol++;}
			}else{
				if(ncol==2){
					rs[l][cl++]=buf[i];
				}else if(ncol==1){
					cpos[cl++]=buf[i];
				}else if(ncol==3){
					if(cl==0){A1[l]=buf[i];}else{A1[l]='0';}
					cl++;
				}else if(ncol==4){
					if(cl==0){
						A2[l]=buf[i];
						if(A2[l]=='-'){A2[l]='1';A1[l]='0';}
					}else{// allele length > 1
						A2[l]='1';A1[l]='0';
					}
					cl++;
				}
			}
		}
	}
	fprintf(stderr, "marker position: [%ld..%ld]\n",pos[0],pos[N-1]);
	//fprintf(stderr, "marker position: [%c %c %c %c..%c %c %c %c]\n",A1[0],A1[1],A1[2],A1[3],A1[N-4],A1[N-3],A1[N-2],A1[N-1]);
	//fprintf(stderr, "marker position: [%c %c %c %c..%c %c %c %c]\n",A2[0],A2[1],A2[2],A2[3],A2[N-4],A2[N-3],A2[N-2],A2[N-1]);
	
	char* chr;
	char* c1;
	char* seq;
	char* num;
	chr = (char*)calloc(100, sizeof(char));
	seq = (char*)calloc(1000, sizeof(char));
	c1 =  (char*)calloc(1000, sizeof(char));
	num = (char*)calloc(100, sizeof(char));
	if(num==NULL || c1==NULL || seq==NULL || chr==NULL){fprintf(stderr, "memory allocation error!\n"); return 0;}
	long left, right;
	long* at;
	at = (long*)calloc(100, sizeof(long));
	long j,j0=0;
	long l0=0, l1=0;
	while(scanf("%s\t%ld\t%ld\t%s\t%s", chr, &left, &right, c1, seq)!=EOF){
		l=0;
		int flag=0;
//fprintf(stderr, "%s\t%ld\t%ld\t%s\t%s\n", chr, left, right, c1, seq);
		for(j=j0; j<N; j++){
			if(pos[j]>right){break;}
			if(pos[j]>=left){l++;}else{j0=j+1;}
		}
		if(l>0){
			// flag: number of snps existing in the fragment
			flag=parseCigarPoint(left, c1, seq, pos+j0, l, A1+j0, A2+j0, Y+3*j0, num);
			    parseCigarPoint2(left, c1, seq, pos+j0, l, A1+j0, ds+j0, num, flag);
		}
		if(printFrag==1){// tabix out put
			if( (overlap==1&&flag>0) || (overlap==0&&flag==0) ){
				printf("%s\t%ld\t%ld\t%s\t%s\n", chr, left, right, c1, seq);
			}
		}
		if(flag==0){// no snp
			l1++;
		}
		//	//printf("%s\t%ld\t%ld\t%s\t%s\n", chr, left, right, c1, seq);
		//}else{// more than one snp | flag captures the number of snps
		//	printf("%d\n", flag);
		//}
		l0++;
	}
	if(printFrag==0){
		for(j=0; j<N; j++){
			printf("%s\t%ld\t%c\t%c\t%ld\t%ld\t%ld\t%lf\n", rs[j], pos[j], A1[j], A2[j], Y[j*3], Y[j*3+1], Y[j*3+2], ds[j]);
		}
	}
	//FILE* fcount;
	//fcount=fopen("count.bin","wb");
	//fwrite(Y,sizeof(long),N*3,fcount);
	//fclose(fcount);
	fprintf(stderr, "%ld out of %ld fragments overlapped with SNPs\n", l0-l1, l0);
	return 0;
}
/**
 * For that test you would need to luanch camera
 * so it would punch a hole for you.
 */
int main(int, char**)
{
   LOGE("%s start", LOG_TAG);

   overlay2::GenericPipe<ovutils::FB0> pipe;
   overlay2::RotatorBase* r = new overlay2::NullRotator();
   LOGE("Using null rotator");
   bool ret = pipe.open(r);
   OVASSERT(ret, "Failed to open pipe");

   LOGE("start ...");
   ovutils::Whf whf(1024, 600, HAL_PIXEL_FORMAT_YCbCr_420_SP_TILED);
   /* since we are using camera apk for punching a hole for us
    * we need ZOERDER_1 here so it will be on top of camera */
   ovutils::eMdpFlags flags = ovutils::OV_MDP_FLAGS_NONE;
   ovutils::PipeArgs args(flags,
                          ovutils::OVERLAY_TRANSFORM_0,
                          whf,
                          ovutils::WAIT,
                          ovutils::ZORDER_1,
                          ovutils::IS_FG_OFF,
                          ovutils::ROT_FLAG_DISABLED,
                          ovutils::PMEM_SRC_SMI,
                          ovutils::RECONFIG_OFF);
   ret = pipe.start(args);

   OVASSERT(ret, "Failed to start pipe");

   // let's try openning /dev/zero and mmap it.
   LOGE("Open /dev/pmem_adsp");
   overlay2::OvMem m;
   uint32_t bfsz = 1024*600*4;
   ret = m.open(ovutils::PMEM_SRC_ADSP,
                1,     // one buf
                bfsz); //size
   OVASSERT(ret, "Failed to open /dev/pmem_adsp pipe");
   m.dump();
   ::memset(m.addr(), 0, bfsz);
   pipe.setMemoryId(m.getFD());
   ovutils::Dim dim(0, 0, 1024, 600); // x,y,w,h
   ret = pipe.setPosition(dim);
   OVASSERT(ret, "Failed to setPosition");

   LOGE("Before play ...");
   pipe.dump();
   enum { NUM_PLAY = 10 };
   for (uint32_t i=0; i < NUM_PLAY; ++i) {
      ret = pipe.queueBuffer(0); // offset 0
      OVASSERT(ret, "Failed to queueBuffer");
      sleep(1);
   }

   ret = r->close();
   OVASSERT(ret, "Error in rotator close");

   ret = pipe.close();
   OVASSERT(ret, "Error in pipe close");

   ret = m.close();

   delete r;
   r=0;
   LOGE("%s end", LOG_TAG);
   return 0;
}
Example #6
0
int SD_HW_GetMaxBusWidth(int iSlotIndex)
{
	int iIndex = SD_HW_Convert_SlotIndex_To_HwSlotInfoIndex(iSlotIndex);
	SD_ASSERT( iIndex < (int)dim(sSdHwSlotInfo) );
	return sSdHwSlotInfo[iIndex].iMaxBusWidth;
}
                }
                pKbdEventRmpCurr->uiVk = pvkMap->uiVkGenerated;
            }
        }
    }

    return cRmpKbdEvents;    
}
    

static DEVICE_LAYOUT dlMatrixEngUs =
{
    sizeof(DEVICE_LAYOUT),
    MATRIX_PDD,
    rgscvkMatrixEngUSTables,
    dim(rgscvkMatrixEngUSTables),
    MatrixUsRemapVKey,
};

extern "C"
BOOL
Matrix(
    PDEVICE_LAYOUT pDeviceLayout
    )
{
    SETFNAME(_T("Matrix"));

    BOOL fRet = FALSE;

    if (pDeviceLayout == NULL)
    {
 // second diag (used in LU decomposition), saved in m_lower
 double CBandMatrix::saved_diag(int i) const
 {
     assert( (i>=0) && (i<dim()) );
     return m_lower[0][i];
 }
Example #9
0
void Action_AtomicCorr::Print() {
  int idx, idx3, vec1size;
  Vec3 V1, V2;
  mprintf("    ATOMICCORR: Calculating correlations between %s vectors:\n",
          ModeString[acorr_mode_]);
  if (atom_vectors_.empty()) {
    mprinterr("Error: No vectors calculated.\n");
    return;
  }
  DataSet_MatrixFlt* tmatrix = static_cast<DataSet_MatrixFlt*>( dset_ );
  tmatrix->AllocateTriangle( atom_vectors_.size() );
  // Calculate correlation coefficient of each atomic vector to each other
  ACvector::iterator av_end = atom_vectors_.end();
  ACvector::iterator av_end1 = av_end - 1;
  ProgressBar progress( tmatrix->Size() );
  int iprogress = 0;
  for (ACvector::const_iterator vec1 = atom_vectors_.begin(); vec1 != av_end1; ++vec1)
  {
    for (ACvector::const_iterator vec2 = vec1 + 1; vec2 != av_end; ++vec2)
    {
      double corr_coeff = 0.0;
      progress.Update( iprogress++ );
      // If vectors are too close, skip. vec2 always > vec1
      if ( (*vec2) - (*vec1) > min_ ) {
        // Make sure same # of frames in each and not empty
        if ( vec1->empty() || vec2->empty() ) {
          mprintf("Warning: A vector is empty: Vec%zu=%zu, Vec%zu=%zu\n",
                  vec1 - atom_vectors_.begin(), vec1->size(),
                  vec2 - atom_vectors_.begin(), vec2->size());
        } else if ( vec1->size() != vec2->size() ) {
          mprintf("Warning: Vec %zu and Vec %zu do not have same # of frames.\n",
                  vec1 - atom_vectors_.begin(), vec2 - atom_vectors_.begin());
        } else {
          vec1size = (int)(vec1->size() / 3);
#ifdef _OPENMP
#pragma omp parallel private(idx, idx3, V1, V2) reduction(+: corr_coeff)
{
#pragma omp for
#endif
          for (idx = 0; idx < vec1size; ++idx) {
            idx3 = idx * 3;
            V1 = vec1->VXYZ(idx3);
            V2 = vec2->VXYZ(idx3);
            V1.Normalize();
            V2.Normalize();
            corr_coeff += (V1 * V2);
          }
#ifdef _OPENMP
} // END pragma omp parallel
#endif
          corr_coeff /= (double)vec1size;
          if (fabs(corr_coeff) <= cut_)
            corr_coeff = 0.0;
        }
      }
      tmatrix->AddElement( corr_coeff );
    } // END inner loop
  } // END outer loop

  if (acorr_mode_ == ATOM) {
    Dimension dim(1.0, 1.0, "Atom");
    dset_->SetDim(Dimension::X, dim);
    dset_->SetDim(Dimension::Y, dim);
  } else {
    Dimension dim(1.0, 1.0, "Residue");
    dset_->SetDim(Dimension::X, dim);
    dset_->SetDim(Dimension::Y, dim);
  }
  std::string labels;
  for (ACvector::const_iterator atom = atom_vectors_.begin();
                                atom != atom_vectors_.end(); ++atom)
    labels += ( atom->Label() + "," );
  if (outfile_ != 0)
    outfile_->ProcessArgs( "xlabels " + labels + " ylabels " + labels );
}
separation find_wheel_minor(matroid_permuted <MatroidType>& permuted_matroid, matrix_permuted <MatrixType>& permuted_matrix,
                            matroid_element_set& extra_elements)
{
    assert (permuted_matrix.size1() >= 3 && permuted_matroid.size2() >= 3);

    /// Permute 1's in first row to the left.
    matroid_reorder_columns(permuted_matroid, permuted_matrix, 0, 1, 0, permuted_matroid.size2(), std::greater <int>());
    size_t count_first_row_ones = matrix_count_property_column_series(permuted_matrix, 0, 1, 0, permuted_matrix.size2(), is_non_zero());

    /// Trivial 1-separation
    if (count_first_row_ones == 0)
    {
        return separation(std::make_pair(1, 0));
    }

    matroid_reorder_rows(permuted_matroid, permuted_matrix, 1, permuted_matroid.size1(), 0, 1, std::greater <int>());
    size_t count_first_column_ones = matrix_count_property_row_series(permuted_matrix, 0, permuted_matroid.size1(), 0, 1, is_non_zero());

    /// 1- or 2-separation
    if (count_first_row_ones == 1)
    {
        if (count_first_column_ones == 0)
        {
            return separation(std::make_pair(1, 1));
        }
        else
        {
            return separation(std::make_pair(1, 1), std::make_pair(1, 0));
        }
    }
    else if (count_first_column_ones == 1)
    {
        return separation(std::make_pair(1, 1), std::make_pair(0, 1));
    }

    assert ((permuted_matrix(0,0) == 1) && (permuted_matrix(1,0) == 1) && (permuted_matrix(0,1) == 1));

    /// Ensure we have a 2x2 block of ones
    if (permuted_matrix(1, 1) != 1)
    {
        matroid_binary_pivot(permuted_matroid, permuted_matrix, 0, 0);
        extra_elements.insert(permuted_matroid.name1(0));
        extra_elements.insert(permuted_matroid.name2(0));
    }

    assert ((permuted_matrix(0,0) == 1) && (permuted_matrix(1,0) == 1) && (permuted_matrix(0,1) == 1) && (permuted_matrix(1,1) == 1));

    /// Grow the block to a set-maximal one.
    matroid_reorder_columns(permuted_matroid, permuted_matrix, 0, 2, 2, permuted_matroid.size2(), std::greater <int>());
    size_t block_width = 2 + matrix_count_property_column_series(permuted_matrix, 0, 2, 2, permuted_matrix.size2(), is_all_ones());

    matroid_reorder_rows(permuted_matroid, permuted_matrix, 2, permuted_matroid.size1(), 0, block_width, std::greater <int>());

    size_t block_height = 2 + matrix_count_property_row_series(permuted_matrix, 2, permuted_matrix.size1(), 0, block_width, is_all_ones());

    /// Search for a path in BFS graph
    zero_block_matrix_modifier modifier(block_height, block_width);
    matrix_modified <matrix_permuted <MatrixType> , zero_block_matrix_modifier> modified_matrix(permuted_matrix, modifier);
    bipartite_graph_dimensions dim(permuted_matrix.size1(), permuted_matrix.size2());
    std::vector <bipartite_graph_dimensions::index_type> start_nodes(block_height);
    for (size_t i = 0; i < block_height; i++)
        start_nodes[i] = dim.row_to_index(i);
    std::vector <bipartite_graph_dimensions::index_type> end_nodes(block_width);
    for (size_t i = 0; i < block_width; i++)
        end_nodes[i] = dim.column_to_index(i);

    std::vector <bipartite_graph_bfs_node> bfs_result;
    bool found_path = bipartite_graph_bfs(modified_matrix, dim, start_nodes, end_nodes, false, bfs_result);

    /// There must be a 2-separation.
    if (!found_path)
    {
        std::pair <size_t, size_t> split(0, 0);

        /// Swap unreachable rows to top
        std::vector <int> reachable(permuted_matrix.size1());
        for (size_t i = 0; i < permuted_matrix.size1(); ++i)
        {
            const bipartite_graph_bfs_node& node = bfs_result[dim.row_to_index(i)];
            int value = (node.is_reachable() ? (node.distance > 0 ? 2 : 1) : 0);
            reachable[permuted_matrix.perm1()(i)] = value;
            if (value == 0)
                split.first++;
        }
        vector_less <int, std::less <int> > less(reachable, std::less <int>());

        sort(permuted_matrix.perm1(), less);
        permuted_matroid.perm1() = permuted_matrix.perm1();

        /// Swap unreachable columns to left
        reachable.resize(permuted_matrix.size2());
        for (size_t i = 0; i < permuted_matrix.size2(); ++i)
        {
            const bipartite_graph_bfs_node& node = bfs_result[dim.column_to_index(i)];
            int value = (node.is_reachable() ? 2 : (node.distance == -2 ? 1 : 0));
            reachable[permuted_matrix.perm2()(i)] = value;
            if (value < 2)
                split.second++;
        }

        sort(permuted_matrix.perm2(), less);
        permuted_matroid.perm2() = permuted_matrix.perm2();

        return separation(split, std::make_pair(split.first, split.second - 1));
    }

    /// Go back along the path to find the nearest endpoint.
    bipartite_graph_dimensions::index_type nearest_end = 0;
    for (std::vector <bipartite_graph_dimensions::index_type>::const_iterator iter = end_nodes.begin(); iter != end_nodes.end(); ++iter)
    {
        if (bfs_result[*iter].is_reachable())
            nearest_end = *iter;
    }

    assert (bfs_result[nearest_end].is_reachable());

    size_t w3_one_column = dim.index_to_column(nearest_end);
    size_t nearest_distance = bfs_result[nearest_end].distance + 1;

    assert (nearest_distance % 2 == 0);

    size_t last_index = nearest_end;
    size_t current_index = bfs_result[last_index].predecessor;

    /// Find indices for basic W3-parts.
    size_t w3_one_row = 0;
    size_t w3_path_column = 0;
    size_t w3_path_row = dim.index_to_row(current_index);
    size_t w3_zero_column = 0;
    while (permuted_matrix(w3_path_row, w3_zero_column) != 0)
    {
        w3_zero_column++;
        assert (w3_zero_column < block_width);
    }

    /// Apply path shortening technique.
    while (last_index != current_index)
    {
        std::pair <size_t, size_t> coords = dim.indexes_to_coordinates(current_index, last_index);

        if ((bfs_result[current_index].distance % 2 == 0) && (bfs_result[current_index].distance >= 2) && (bfs_result[current_index].distance + 2
                < (int) nearest_distance))
        {
            matroid_binary_pivot(permuted_matroid, permuted_matrix, coords.first, coords.second);
            extra_elements.insert(permuted_matroid.name1(coords.first));
            extra_elements.insert(permuted_matroid.name2(coords.second));
        }

        if (bfs_result[current_index].distance == 1)
        {
            assert (dim.is_column(current_index));

            w3_path_column = dim.index_to_column(current_index);
        }
        else if (bfs_result[current_index].distance == 0)
        {
            assert (dim.is_row(current_index));

            w3_one_row = dim.index_to_row(current_index);
        }

        last_index = current_index;
        current_index = bfs_result[current_index].predecessor;
    }

    /// Collect more W3-indices.
    size_t w3_zero_row = 0;
    while (permuted_matrix(w3_zero_row, w3_path_column) != 0)
    {
        w3_zero_row++;
        assert (w3_zero_row< block_height);
    }

    assert (permuted_matrix (w3_one_row, w3_one_column) == 1);
    assert (permuted_matrix (w3_one_row, w3_zero_column) == 1);
    assert (permuted_matrix (w3_one_row, w3_path_column) == 1);
    assert (permuted_matrix (w3_zero_row, w3_one_column) == 1);
    assert (permuted_matrix (w3_zero_row, w3_zero_column) == 1);
    assert (permuted_matrix (w3_zero_row, w3_path_column) == 0);
    assert (permuted_matrix (w3_path_row, w3_one_column) == 1);
    assert (permuted_matrix (w3_path_row, w3_zero_column) == 0);
    assert (permuted_matrix (w3_path_row, w3_path_column) == 1);

    /// Some normalization
    if (w3_zero_row > w3_one_row)
    {
        matroid_permute1(permuted_matroid, permuted_matrix, w3_one_row, w3_zero_row);
        std::swap(w3_one_row, w3_zero_row);
    }
    if (w3_one_row > w3_path_row)
    {
        matroid_permute1(permuted_matroid, permuted_matrix, w3_path_row, w3_one_row);
        std::swap(w3_path_row, w3_one_row);
    }

    if (w3_zero_column > w3_one_column)
    {
        matroid_permute2(permuted_matroid, permuted_matrix, w3_one_column, w3_zero_column);
        std::swap(w3_one_column, w3_zero_column);
    }
    if (w3_one_column > w3_path_column)
    {
        matroid_permute2(permuted_matroid, permuted_matrix, w3_path_column, w3_one_column);
        std::swap(w3_path_column, w3_one_column);
    }

    matroid_permute1(permuted_matroid, permuted_matrix, 0, w3_zero_row);
    matroid_permute1(permuted_matroid, permuted_matrix, 1, w3_one_row);
    matroid_permute1(permuted_matroid, permuted_matrix, 2, w3_path_row);

    matroid_permute2(permuted_matroid, permuted_matrix, 0, w3_zero_column);
    matroid_permute2(permuted_matroid, permuted_matrix, 1, w3_one_column);
    matroid_permute2(permuted_matroid, permuted_matrix, 2, w3_path_column);

    return separation();
}
Example #11
0
    /*--------------------------------------------------------------------------------
        Function    : InventoryScreen::refresh
        Description : draws the InventoryScreen to the game window
        Inputs      : None
        Outputs     : updated InventoryScreen
        Return      : void
    --------------------------------------------------------------------------------*/
    void InventoryScreen::refresh()
    {
        Point dim(screen.getWidth(), screen.getHeight());

        // set the colorscheme of the selected line
        TCODConsole::setColorControl(TCOD_COLCTRL_1, TCODColor::white, TCODColor::blue);

        // create a vector of the different item symbols
        vector< pair<int, TCODColor> > tabChars;
        tabChars.push_back(pair<int, TCODColor>('\\', UI_FORE_COLOR));
        tabChars.push_back(pair<int, TCODColor>('[', UI_FORE_COLOR));
        tabChars.push_back(pair<int, TCODColor>('!', UI_FORE_COLOR));
        tabChars.push_back(pair<int, TCODColor>('*', UI_FORE_COLOR));

        // draw interface
        int x=0, y=2;
        //screen.printEx(dim.X()/2, 0, TCOD_BKGND_SET, TCOD_CENTER, 
        //               (client->personalStats.name() + string("'s Inventory")).c_str());
        screen.printEx(dim.X()/2, 0, TCOD_BKGND_SET, TCOD_CENTER, "Inventory");

        // 'start' is the point at which the folder contents are drawn
        Point start = drawFolders(x, y, dim, tabChars);

        // draw the information line
        x = start.X();
        y = start.Y();
        screen.print(x+1, y++, "Qt.  Item");
        screen.hline(x, y++, dim.X()-3);

        // update start position to where items will be drawn
        start.setY(y);
        
        linesPerPage = dim.Y()-y;
        currentPage = (selectedLine==0) ? 0 : selectedLine / (linesPerPage-1);

        int numItems = client->inventory.getIndexSize(selectedTab);

        if(numItems <= 0) return;

        drawScrollBar(Point(dim.X()-2, y), linesPerPage, currentPage, 
                      (numItems/linesPerPage)+1);

        // determine at what line should be highlighted
        int hlOffset = selectedLine % ((currentPage==0) ? linesPerPage : linesPerPage-1); 

        // set an iterator to the lowest spot that will show the selected line
        vector<ItemPtr>::const_iterator it;
        it = client->inventory.getIndexBegin(selectedTab) + (currentPage*linesPerPage) - currentPage;

        for(; it!=client->inventory.getIndexEnd(selectedTab); ++it, ++y)
        {
            // ignore lines that are off the display area
            if(y >= start.Y()+linesPerPage-1) break;

            // construct the display string
            // three spaces are allocated to the item count number.  The buffer string
            // ensures that this number is right aligned in this space.
            string buffer = "";
            unsigned int c = (*it)->getCount();
            while(c<100) { buffer += " "; c *= 10;}
            string disp = buffer + boost::lexical_cast<string>((*it)->getCount()) + "  " + (*it)->getName();

            // if this is the selected line on the current page, highlight it
            if(y == (hlOffset) + start.Y()) 
            {
                disp = "%c" + disp + "%c";
                screen.printEx(start.X(), y, TCOD_BKGND_SET, TCOD_LEFT, 
                               disp.c_str(), TCOD_COLCTRL_1, TCOD_COLCTRL_STOP);
            }
            else // display the line normally
            {
                screen.printEx(start.X(), y, TCOD_BKGND_SET, TCOD_LEFT, disp.c_str()); 
            }
        }
    }
Example #12
0
/// \brief Sets the matrix to the \p nrows x \p ncols zero matrix.
void matrix::zero(int nrows, int ncols) {

    dim(nrows, ncols);
    for(int i=0;i<nf*nc;i++) p[i]=0;

}
int main(int, char**)
{
   LOGE("OverlayCtrlTest start");

   overlay2::Ctrl ctrl;
   overlay2::RotatorBase* rot = new overlay2::NullRotator();

   // open rot here
   bool ret = rot->open();
   OVASSERT(ret, "Rotator failed to open");
   ovutils::PipeArgs args(ovutils::OV_MDP_FLAGS_NONE,//flags PIPE SHARED
                          ovutils::OVERLAY_TRANSFORM_0,
                          ovutils::Whf(),
                          ovutils::WAIT,
                          ovutils::ZORDER_0,
                          ovutils::IS_FG_OFF,
                          ovutils::ROT_FLAG_ENABLED,
                          ovutils::PMEM_SRC_ADSP,
                          ovutils::RECONFIG_OFF);
   ret = rot->remap(ROT_NUM_BUF, args);
   OVASSERT(ret, "Rotator failed to remap");

   ret = ctrl.open(ovutils::FB0, rot);
   OVASSERT(ret, "Ctrl failed to open");
   ovutils::Whf whf(100, 200, HAL_PIXEL_FORMAT_RGBA_8888);
   ovutils::eMdpFlags flags = ovutils::OV_MDP_FLAGS_NONE;
   ret = ctrl.start(args);
   OVASSERT(ret, "Ctrl failed to start");
   ctrl.dump();

   LOGE("setPosition ...");
   ovutils::Dim dim(0, 0, 50, 100);
   ret = ctrl.setPosition(dim);
   OVASSERT(ret, "Ctrl failed to setPosition");
   ctrl.dump();

   LOGE("setParameter ...");
   ovutils::Params p ( ovutils::OVERLAY_DITHER, 0 );
   ret = ctrl.setParameter(p);
   OVASSERT(ret, "Ctrl failed to setParameter");
   ctrl.dump();

   LOGE("setSource ...");
   ovutils::PipeArgs args1(flags,
                           ovutils::OVERLAY_TRANSFORM_0,
                           ovutils::Whf(75, 150, HAL_PIXEL_FORMAT_RGBA_8888),
                           ovutils::WAIT,
                           ovutils::ZORDER_0,
                           ovutils::IS_FG_OFF,
                           ovutils::ROT_FLAG_DISABLED,
                           ovutils::PMEM_SRC_SMI,
                           ovutils::RECONFIG_OFF);
   ret = ctrl.setSource(args1);
   OVASSERT(ret, "Ctrl failed to setSource");
   ctrl.commit();
   ctrl.dump();

   ctrl.close();
   rot->close();
   delete rot;

   LOGE("OverlayCtrlTest end");
   return 0;
}
Example #14
0
void SPxSolver::qualRedCostViolation(Real& maxviol, Real& sumviol) const
{   
   maxviol = 0.0;
   sumviol = 0.0;

   int i;
   // TODO:   y = c_B * B^-1  => coSolve(y, c_B)
   //         redcost = c_N - yA_N 
   // solve system "x = e_i^T * B^-1" to get i'th row of B^-1
   // DVector y( nRows() );
   // basis().coSolve( x, spx->unitVector( i ) );
   // DVector rdcost( nCols() );
#if 0 // un-const
   if (lastUpdate() > 0)
      factorize();

   computePvec();

   if (type() == ENTER)
      computeTest();
#endif
   if (type() == ENTER)
   {
      for(i = 0; i < dim(); ++i)
      {
         Real x = coTest()[i];
         
         if (x < 0.0)
         {
            sumviol -= x;
            
            if (x < maxviol)
               maxviol = x;
         }
      }
      for(i = 0; i < coDim(); ++i)
      {
         Real x = test()[i];
         
         if (x < 0.0)
         {
            sumviol -= x;
            
            if (x < maxviol)
               maxviol = x;
         }
      } 
   }
   else
   {
      assert(type() == LEAVE);

      for(i = 0; i < dim(); ++i)
      {
         Real x = fTest()[i];
         
         if (x < 0.0)
         {
            sumviol -= x;
            
            if (x < maxviol)
               maxviol = x;
         }
      }
   }
   maxviol *= -1;
}
Example #15
0
void RandomPCA::pca(MatrixXd &X, int method, bool transpose,
   unsigned int ndim, unsigned int nextra, unsigned int maxiter, double tol,
   long seed, int kernel, double sigma, bool rbf_center,
   unsigned int rbf_sample, bool save_kernel, bool do_orth, bool do_loadings)
{
   unsigned int N;

   if(kernel != KERNEL_LINEAR)
   {
      transpose = false;
      verbose && std::cout << timestamp()
	 << " Kernel not linear, can't transpose" << std::endl;
   }

   verbose && std::cout << timestamp() << " Transpose: " 
      << (transpose ? "yes" : "no") << std::endl;

   if(transpose)
   {
      if(stand_method != STANDARDIZE_NONE)
	  X_meansd = standardize_transpose(X, stand_method, verbose);
      N = X.cols();
   }
   else
   {
      if(stand_method != STANDARDIZE_NONE)
	 X_meansd = standardize(X, stand_method, verbose);
      N = X.rows();
   }

   unsigned int total_dim = ndim + nextra;
   MatrixXd R = make_gaussian(X.cols(), total_dim, seed);
   MatrixXd Y = X * R;
   verbose && std::cout << timestamp() << " dim(Y): " << dim(Y) << std::endl;
   normalize(Y);
   MatrixXd Yn;

   verbose && std::cout << timestamp() << " dim(X): " << dim(X) << std::endl;
   MatrixXd K; 
   if(kernel == KERNEL_RBF)
   {
      if(sigma == 0)
      {
	 unsigned int med_samples = fminl(rbf_sample, N);
      	 double med = median_dist(X, med_samples, seed, verbose);
      	 sigma = sqrt(med);
      }
      verbose && std::cout << timestamp() << " Using RBF kernel with sigma="
	 << sigma << std::endl;
      K.noalias() = rbf_kernel(X, sigma, rbf_center, verbose);
   }
   else
   {
      verbose && std::cout << timestamp() << " Using linear kernel" << std::endl;
      K.noalias() = X * X.transpose() / (N - 1);
   }

   //trace = K.diagonal().array().sum() / (N - 1);
   trace = K.diagonal().array().sum();
   verbose && std::cout << timestamp() << " Trace(K): " << trace 
      << " (N: " << N << ")" << std::endl;

   verbose && std::cout << timestamp() << " dim(K): " << dim(K) << std::endl;
   if(save_kernel)
   {
      verbose && std::cout << timestamp() << " saving K" << std::endl;
      save_text("kernel.txt", K);
   }

   for(unsigned int iter = 0 ; iter < maxiter ; iter++)
   {
      verbose && std::cout << timestamp() << " iter " << iter;
      Yn.noalias() = K * Y;
      if(do_orth)
      {
	 verbose && std::cout << " (orthogonalising)";
	 ColPivHouseholderQR<MatrixXd> qr(Yn);
	 MatrixXd I = MatrixXd::Identity(Yn.rows(), Yn.cols());
	 Yn = qr.householderQ() * I;
	 Yn.conservativeResize(NoChange, Yn.cols());
      }
      else
	 normalize(Yn);

      double diff =  (Y -  Yn).array().square().sum() / Y.size(); 
      verbose && std::cout << " " << diff << std::endl;
      Y.noalias() = Yn;
      if(diff < tol)
	 break;
   }

   verbose && std::cout << timestamp() << " QR begin" << std::endl;
   ColPivHouseholderQR<MatrixXd> qr(Y);
   MatrixXd Q = MatrixXd::Identity(Y.rows(), Y.cols());
   Q = qr.householderQ() * Q;
   Q.conservativeResize(NoChange, Y.cols());
   verbose && std::cout << timestamp() << " dim(Q): " << dim(Q) << std::endl;
   verbose && std::cout << timestamp() << " QR done" << std::endl;

   MatrixXd B = Q.transpose() * X;
   verbose && std::cout << timestamp() << " dim(B): " << dim(B) << std::endl;

   MatrixXd Et;
   pca_small(B, method, Et, d, verbose);
   verbose && std::cout << timestamp() << " dim(Et): " << dim(Et) << std::endl;

   d = d.array() / (N - 1);

   if(transpose)
   {
      V.noalias() = Q * Et;
      // We divide P by sqrt(N - 1) since X has not been divided
      // by it (but B has)
      P.noalias() = X.transpose() * V;
      VectorXd s = 1 / (d.array().sqrt() * sqrt(N - 1));
      MatrixXd Dinv = s.asDiagonal();
      U = P * Dinv;
   }
   else
   {
      // P = U D = X V
      U.noalias() = Q * Et;
      P.noalias() = U * d.asDiagonal();
      if(do_loadings)
      {
	 VectorXd s = 1 / (d.array().sqrt() * sqrt(N - 1));
	 MatrixXd Dinv = s.asDiagonal();
	 V = X.transpose() * U * Dinv;
      }
   }

   P.conservativeResize(NoChange, ndim);
   U.conservativeResize(NoChange, ndim);
   V.conservativeResize(NoChange, ndim);
   d.conservativeResize(ndim);
   pve = d.array() / trace;
}
//! constructor
CGUIMessageBox::CGUIMessageBox(IGUIEnvironment* environment, const wchar_t* caption,
                               const wchar_t* text, s32 flags,
                               IGUIElement* parent, s32 id, core::rect<s32> rectangle)
	: CGUIWindow(environment, parent, id, rectangle), StaticText(0),
	OkButton(0), YesButton(0), NoButton(0), CancelButton(0)
{
	#ifdef _DEBUG
	setDebugName("CGUIMessageBox");
	#endif

	// remove focus
	Environment->setFocus(0);

	// remove buttons

	getMaximizeButton()->remove();
	getMinimizeButton()->remove();

	if (caption)
		setText(caption);

	IGUISkin* skin = Environment->getSkin();

	s32 buttonHeight = skin->getSize(EGDS_BUTTON_HEIGHT);
	s32 buttonWidth = skin->getSize(EGDS_BUTTON_WIDTH);
	s32 titleHeight = skin->getSize(EGDS_WINDOW_BUTTON_WIDTH)+2;
	s32 buttonDistance = skin->getSize(EGDS_WINDOW_BUTTON_WIDTH);

	// add static multiline text

	core::dimension2d<s32> dim(AbsoluteClippingRect.getWidth() - buttonWidth,
	                           AbsoluteClippingRect.getHeight() - (buttonHeight * 3));
	core::position2d<s32> pos((AbsoluteClippingRect.getWidth() - dim.Width) / 2,
	                          buttonHeight / 2 + titleHeight);

	StaticText = Environment->addStaticText(text,
	                                        core::rect<s32>(pos, dim), false, false, this);
	StaticText->setWordWrap(true);
	StaticText->grab();

	// adjust static text height

	s32 textHeight = StaticText->getTextHeight();
	core::rect<s32> tmp = StaticText->getRelativePosition();
	tmp.LowerRightCorner.Y = tmp.UpperLeftCorner.Y + textHeight;
	StaticText->setRelativePosition(tmp);
	dim.Height = textHeight;

	// adjust message box height

	tmp = getRelativePosition();
	s32 msgBoxHeight = textHeight + (s32)(2.5f * buttonHeight) + titleHeight;

	// adjust message box position

	tmp.UpperLeftCorner.Y = (parent->getAbsolutePosition().getHeight() - msgBoxHeight) / 2;
	tmp.LowerRightCorner.Y = tmp.UpperLeftCorner.Y + msgBoxHeight;
	setRelativePosition(tmp);


	// add buttons

	s32 countButtons = 0;
	if (flags & EMBF_OK) ++countButtons;
	if (flags & EMBF_CANCEL) ++countButtons;
	if (flags & EMBF_YES) ++countButtons;
	if (flags & EMBF_NO) ++countButtons;

	core::rect<s32> btnRect;
	btnRect.UpperLeftCorner.Y = pos.Y + dim.Height + buttonHeight / 2;
	btnRect.LowerRightCorner.Y = btnRect.UpperLeftCorner.Y + buttonHeight;
	btnRect.UpperLeftCorner.X = (AbsoluteClippingRect.getWidth() -
	                             ((buttonWidth + buttonDistance)*countButtons)) / 2;
	btnRect.LowerRightCorner.X = btnRect.UpperLeftCorner.X + buttonWidth;

	// add ok button
	if (flags & EMBF_OK)
	{
		OkButton = Environment->addButton(btnRect, this);
		OkButton->setText(skin->getDefaultText(EGDT_MSG_BOX_OK));
		OkButton->grab();

		btnRect.LowerRightCorner.X += buttonWidth + buttonDistance;
		btnRect.UpperLeftCorner.X += buttonWidth + buttonDistance;

		Environment->setFocus(OkButton);
	}

	// add yes button
	if (flags & EMBF_YES)
	{
		YesButton = Environment->addButton(btnRect, this);
		YesButton->setText(skin->getDefaultText(EGDT_MSG_BOX_YES));
		YesButton->grab();

		btnRect.LowerRightCorner.X += buttonWidth + buttonDistance;
		btnRect.UpperLeftCorner.X += buttonWidth + buttonDistance;
	}

	// add no button
	if (flags & EMBF_NO)
	{
		NoButton = Environment->addButton(btnRect, this);
		NoButton->setText(skin->getDefaultText(EGDT_MSG_BOX_NO));
		NoButton->grab();

		btnRect.LowerRightCorner.X += buttonWidth + buttonDistance;
		btnRect.UpperLeftCorner.X += buttonWidth + buttonDistance;
	}

	// add cancel button
	if (flags & EMBF_CANCEL)
	{
		CancelButton = Environment->addButton(btnRect, this);
		CancelButton->setText(skin->getDefaultText(EGDT_MSG_BOX_CANCEL));
		CancelButton->grab();

		btnRect.LowerRightCorner.X += buttonWidth + buttonDistance;
		btnRect.UpperLeftCorner.X += buttonWidth + buttonDistance;
	}


}
Example #17
0
// ----------------------------------------------------------------------
int Dense3d::setup(map<string,string>&)
{
  iA(_srcPos!=NULL && _srcNor!=NULL && _trgPos!=NULL);
  iA((*_srcPos).m()==dim() && (*_trgPos).m()==dim());  //nothing to do
  return 0;
}
Example #18
0
bool Foam::chemPointISAT<CompType, ThermoType>::inEOA(const scalarField& phiq)
{
    scalarField dphi(phiq-phi());
    bool isMechRedActive = chemistry_.mechRed()->active();
    label dim(0);
    if (isMechRedActive)
    {
        dim = nActiveSpecies_;
    }
    else
    {
        dim = completeSpaceSize() - nAdditionalEqns_;
    }

    scalar epsTemp = 0;
    List<scalar> propEps(completeSpaceSize(), scalar(0));

    for (label i=0; i<completeSpaceSize()-nAdditionalEqns_; i++)
    {
        scalar temp = 0;

        // When mechanism reduction is inactive OR on active species multiply L
        // by dphi to get the distance in the active species direction else (for
        // inactive species), just multiply the diagonal element and dphi
        if
        (
            !(isMechRedActive)
          ||(isMechRedActive && completeToSimplifiedIndex_[i] != -1)
        )
        {
            label si=(isMechRedActive) ? completeToSimplifiedIndex_[i] : i;

            for (label j=si; j<dim; j++)// LT is upper triangular
            {
                label sj=(isMechRedActive) ? simplifiedToCompleteIndex_[j] : j;
                temp += LT_(si, j)*dphi[sj];
            }

            temp += LT_(si, dim)*dphi[idT_];
            temp += LT_(si, dim+1)*dphi[idp_];
            if (variableTimeStep())
            {
                temp += LT_(si, dim+2)*dphi[iddeltaT_];
            }
        }
        else
        {
            temp = dphi[i]/(tolerance_*scaleFactor_[i]);
        }

        epsTemp += sqr(temp);

        if (printProportion_)
        {
            propEps[i] = temp;
        }
    }

    // Temperature
    if (variableTimeStep())
    {
        epsTemp +=
            sqr
            (
                LT_(dim, dim)*dphi[idT_]
               +LT_(dim, dim+1)*dphi[idp_]
               +LT_(dim, dim+2)*dphi[iddeltaT_]
            );
    }
    else
    {
        epsTemp +=
            sqr
            (
                LT_(dim, dim)*dphi[idT_]
               +LT_(dim, dim+1)*dphi[idp_]
            );
    }

    // Pressure
    if (variableTimeStep())
    {
        epsTemp +=
            sqr
            (
                LT_(dim+1, dim+1)*dphi[idp_]
               +LT_(dim+1, dim+2)*dphi[iddeltaT_]
            );
    }
    else
    {
        epsTemp += sqr(LT_(dim+1, dim+1)*dphi[idp_]);
    }

    if (variableTimeStep())
    {
        epsTemp += sqr(LT_[dim+2][dim+2]*dphi[iddeltaT_]);
    }

    if (printProportion_)
    {
        propEps[idT_] = sqr
        (
            LT_(dim, dim)*dphi[idT_]
          + LT_(dim, dim+1)*dphi[idp_]
        );

        propEps[idp_] =
            sqr(LT_(dim+1, dim+1)*dphi[idp_]);

        if (variableTimeStep())
        {
            propEps[iddeltaT_] =
                sqr(LT_[dim+2][dim+2]*dphi[iddeltaT_]);
        }

    }

    if (sqrt(epsTemp) > 1 + tolerance_)
    {
        if (printProportion_)
        {
            scalar max = -1;
            label maxIndex = -1;
            for (label i=0; i<completeSpaceSize(); i++)
            {
                if(max < propEps[i])
                {
                    max = propEps[i];
                    maxIndex = i;
                }
            }
            word propName;
            if (maxIndex >= completeSpaceSize() - nAdditionalEqns_)
            {
                if (maxIndex == idT_)
                {
                    propName = "T";
                }
                else if (maxIndex == idp_)
                {
                    propName = "p";
                }
                else if (maxIndex == iddeltaT_)
                {
                    propName = "deltaT";
                }
            }
            else
            {
                propName = chemistry_.Y()[maxIndex].member();
            }
            Info<< "Direction maximum impact to error in ellipsoid: "
                << propName << endl;
            Info<< "Proportion to the total error on the retrieve: "
                << max/(epsTemp+small) << endl;
        }
        return false;
    }
    else
    {
        return true;
    }
}
Example #19
0
HashGrid3<Vector3> Docking::createHashGrid(){
	
	
	float min_x = 1000;
	float min_y = 1000;
	float min_z = 1000;

	float max_x = -1000;
	float max_y = -1000;
	float max_z = -1000;
	
	//iterate over all atoms of protein A to calc dimesion (s. calcSASSurface)
	for (vector<Vector3>::iterator a_it = positionsA.begin(); a_it != positionsA.end(); a_it++){
			
		Vector3 vec = *a_it;
					
		if (vec.x > max_x){
			max_x = vec.x;
		}
		if (vec.x < min_x){
			min_x = vec.x;
		}

		if (vec.y > max_y){
			max_y = vec.y;
		}

		if (vec.y < min_y){
			min_y = vec.y;
		}

		if (vec.z > max_z){
				max_z = vec.z;
		}

		if (vec.z < min_z){
			min_z = vec.z;
		}


	}
	
	float x = max_x - min_x;
	float y = max_y - min_y;
	float z = max_z - min_z;


	x = ceil(x);
	y = ceil(y);
	z = ceil(z);
	

	Vector3 dim(x, y, z);
	Vector3 origin(min_x, min_y, min_z);

	HashGrid3<Vector3> pointGrid(origin,dim, 4.0);

	Vector3 vec2;


	for (vector<Vector3>::iterator A_it= positionsA.begin(); A_it != positionsA.end(); ++A_it){
		
		vec2 = *A_it;
		pointGrid.insert(vec2,vec2);

	}
	
	return pointGrid;

	
}
Example #20
0
void CameraTestTool::leftButtonDrag(const TPointD &pos, const TMouseEvent &e) {
  m_dragged = true;
  CleanupParameters *cp =
      CleanupSettingsModel::instance()->getCurrentParameters();

  TPointD dp(pos - m_lastPos);
  if (m_scaling != eNoScale) {
    TDimensionD dim(cp->m_camera.getSize());
    TPointD delta;

    // Mid-edge cases
    if (m_scaling == e1M)
      delta = TPointD(dp.x / Stage::inch, 0);
    else if (m_scaling == e0M)
      delta = TPointD(-dp.x / Stage::inch, 0);
    else if (m_scaling == eM1)
      delta = TPointD(0, dp.y / Stage::inch);
    else if (m_scaling == eM0)
      delta = TPointD(0, -dp.y / Stage::inch);
    else {
      // Corner cases
      if (e.isShiftPressed()) {
        // Free adjust
        if (m_scaling == e11)
          delta = TPointD(dp.x / Stage::inch, dp.y / Stage::inch);
        else if (m_scaling == e00)
          delta = TPointD(-dp.x / Stage::inch, -dp.y / Stage::inch);
        else if (m_scaling == e10)
          delta = TPointD(dp.x / Stage::inch, -dp.y / Stage::inch);
        else if (m_scaling == e01)
          delta = TPointD(-dp.x / Stage::inch, dp.y / Stage::inch);
      } else {
        // A/R conservative
        bool xMaximalDp = (fabs(dp.x) > fabs(dp.y));

        if (m_scaling == e11)
          delta.x = (xMaximalDp ? dp.x : dp.y) / Stage::inch;
        else if (m_scaling == e00)
          delta.x = (xMaximalDp ? -dp.x : -dp.y) / Stage::inch;
        else if (m_scaling == e10)
          delta.x = (xMaximalDp ? dp.x : -dp.y) / Stage::inch;
        else if (m_scaling == e01)
          delta.x = (xMaximalDp ? -dp.x : dp.y) / Stage::inch;

        // Keep A/R
        delta.y = delta.x * dim.ly / dim.lx;
      }
    }

    TDimensionD newDim(dim.lx + 2.0 * delta.x, dim.ly + 2.0 * delta.y);
    if (newDim.lx < 2.0 || newDim.ly < 2.0) return;

    cp->m_camera.setSize(newDim,
                         true,    // Preserve DPI
                         false);  // A/R imposed above in corner cases
  } else {
    if (e.isShiftPressed()) {
      TPointD delta = pos - m_firstPos;
      cp->m_offx    = m_firstCameraOffset.x;
      cp->m_offy    = m_firstCameraOffset.y;
      if (fabs(delta.x) > fabs(delta.y)) {
        if (!cp->m_offx_lock) cp->m_offx += -delta.x * (2.0 / Stage::inch);
      } else {
        if (!cp->m_offy_lock) cp->m_offy += -delta.y * (2.0 / Stage::inch);
      }
    } else {
      if (!cp->m_offx_lock) cp->m_offx += -dp.x * (2.0 / Stage::inch);
      if (!cp->m_offy_lock) cp->m_offy += -dp.y * (2.0 / Stage::inch);
    }
  }

  m_lastPos = pos;

  CleanupSettingsModel::instance()->commitChanges();
  invalidate();
}
// Remapping function for the matrix keyboard
static
UINT
WINAPI
MatrixUsRemapVKey(
    const KEYBD_EVENT *pKbdEvents,
    UINT               cKbdEvents,
    KEYBD_EVENT       *pRmpKbdEvents,
    UINT               cMaxRmpKbdEvents
    )
{
    SETFNAME(_T("MatrixUsRemapVKey"));

    static BOOL fFnDown = FALSE;

    UINT cRmpKbdEvents = 0;
    UINT ui;

    if (pRmpKbdEvents == NULL)
    {
        // 1 to 1 mapping
        if (cMaxRmpKbdEvents != 0)
        {
            DEBUGMSG(ZONE_ERROR, (_T("%s: cMaxRmpKbdEvents error!\r\n"), pszFname));
        }
        return cKbdEvents;
    }

    if (pKbdEvents == NULL)
    {
        DEBUGMSG(ZONE_ERROR, (_T("%s: pKbdEvents error!\r\n"), pszFname));
    }

    if (cMaxRmpKbdEvents < cKbdEvents)
    {
        DEBUGMSG(ZONE_ERROR, (_T("%s: Buffer is not large enough!\r\n"), pszFname));
        return 0;
    }

    for (ui = 0; ui < cKbdEvents; ++ui)
    {
        const KEYBD_EVENT *pKbdEventCurr = &pKbdEvents[ui];
        KEYBD_EVENT *pKbdEventRmpCurr = &pRmpKbdEvents[cRmpKbdEvents];

        // Copy the input key event to our remapped list
        pKbdEventRmpCurr->uiVk = pKbdEventCurr->uiVk;
        pKbdEventRmpCurr->uiSc = pKbdEventCurr->uiSc;
        pKbdEventRmpCurr->KeyStateFlags = pKbdEventCurr->KeyStateFlags;

        const VirtualKeyMapping *pvkMap = NULL;
        BOOL fKeyDown = (pKbdEventCurr->KeyStateFlags & KeyStateDownFlag) != 0;
        UINT32 uiVkCurr = pKbdEventCurr->uiVk;

        if (uiVkCurr == VK_MATRIX_FN)
        {
            fFnDown = fKeyDown;
            // Fn virtual key does not get sent to the system so
            // do not increment cRmpKbdEvents.
            DEBUGMSG(ZONE_DEVICELAYOUT, (_T("%s: Fn key is now %s\r\n"),
                pszFname, (fFnDown ? _T("DOWN") : _T("UP"))));
        }
        else
        {
            // We have one key event
            ++cRmpKbdEvents;

            if (fKeyDown)
            {
                // Handle key down
                if (fFnDown)
                {
                    // Fn key is on
                    if (IS_NUMLOCK_ON(pKbdEventCurr->KeyStateFlags))
                    {
                        pvkMap = FindRemappedKey(uiVkCurr, g_rgvkMapNumLock, dim(g_rgvkMapNumLock));
                    }

                    if (pvkMap == NULL)
                    {
                        // NumLock did not effect this key. See if the
                        // Fn key by itself does.                        
                        pvkMap = FindRemappedKey(uiVkCurr, g_rgvkMapFn, dim(g_rgvkMapFn));
                    }
                }
            }
            else
            {
                // Handle key up
                if (fFnDown)
                {
                    // Fn key is on
                    if (IS_NUMLOCK_ON(pKbdEventCurr->KeyStateFlags))
                    {
                        pvkMap = FindRemappedKey(uiVkCurr, g_rgvkMapNumLock, dim(g_rgvkMapNumLock));
                    }

                    if (pvkMap == NULL)
                    {
                        // NumLock did not effect this key. See if the
                        // Fn key by itself does.                        
                        pvkMap = FindRemappedKey(uiVkCurr, g_rgvkMapFn, dim(g_rgvkMapFn));
                    }
                }
            }

            if (pvkMap != NULL)
            {
                // This combination generates a different virtual key
                if (pvkMap->uiVkGenerated == NULL)
                {
                    DEBUGMSG(ZONE_ERROR, (_T("%s: pvkMap->uiVkGenerated error!\r\n"), pszFname));
                }
                pKbdEventRmpCurr->uiVk = pvkMap->uiVkGenerated;
            }
        }
    }

    return cRmpKbdEvents;    
}
 void set_children( unsigned int left )
 {
     index = dim() | (left << 2);
 }
  void RandomObstacles::spawn(OType type , SType subtype){
    OdeHandle handle2 = odeHandle;
    OsgHandle osgHandle2;
    
    double density=((double)rand()/RAND_MAX)*(conf.maxDensity - conf.minDensity) + conf.minDensity;  
    if(subtype == SRandom){
      subtype = (SType)(rand()%4);
    }      
    switch (subtype){
    case Metal: 
      handle2.substance.toMetal(1);
      osgHandle2 = osgHandle.changeColor(Color(0.5,0.5,0.5));
      density = conf.maxDensity;
      break;
    case Plastic: 
      handle2.substance.toPlastic(1);
      osgHandle2 = osgHandle.changeColor(Color(1,1,1));
      break;
    case Rubber: 
      handle2.substance.toRubber(10); 
      osgHandle2 = osgHandle.changeColor(Color(0.2,0.2,0.2));
      break;
    case Foam: 
    default: 
      handle2.substance.toFoam(15);
      osgHandle2 = osgHandle.changeColor(Color(1,1,0));
      density = conf.minDensity;
      break;
    }
      
      
    Pos dim((double)rand() / RAND_MAX, 
            (double)rand() / RAND_MAX, 
            (double)rand() / RAND_MAX);
    dim = (dim & (conf.maxSize - conf.minSize)) + conf.minSize;

    if(type == ORandom) {
      int l = conf.boxRelFreq + conf.sphereRelFreq + conf.capRelFreq;
      int r = rand()%l;
      if(r<conf.boxRelFreq) type = RandomObstacles::Box;
      else if (r<conf.boxRelFreq + conf.sphereRelFreq) type = RandomObstacles::Sphere;
      else type = RandomObstacles::Caps;                               
    }
  
    Primitive* o;
    switch (type){
    case RandomObstacles::Box:
      o = new lpzrobots::Box(dim.x(), dim.y(), dim.z());
      o->init(handle2, dim.x()* dim.y()* dim.z() * density, osgHandle2);
      break;
    case RandomObstacles::Sphere:
      o = new lpzrobots::Sphere(dim.x()/2.0);      
      o->init(handle2, 2.0/3.0*M_PI*pow(dim.x(),3)*density , osgHandle2);
      break;        
    case RandomObstacles::Caps:
    default:
      o = new lpzrobots::Capsule(dim.x()/2.0, dim.z()/2.0); 
      o->init(handle2, M_PI*sqr(dim.x())*dim.z()/8*density, osgHandle2);
      break;
    }

    Pos pos(random_minusone_to_one(0), random_minusone_to_one(0), 1);
    pos = (pos) & conf.area;
    pos.z() += (index%3) * conf.area.z()/2;
    index++;
    o->setPosition(pos * pose);
    obst.push_back(o);
  };
Example #24
0
LIBSBML_CPP_NAMESPACE_USE

int main(int argc, char** argv)
{
    //
    // Creates an SBMLNamespaces object with the given SBML level, version
    // package name.
    //

    SBMLNamespaces sbmlns(2, 3);
    sbmlns.addNamespace(LayoutExtension::getXmlnsL2(), "layout");

    // (NOTES) The above code creating an SBMLNamespaces object can be replaced
    //         with the following other style.
    //
    // (2) Creates a LayoutPkgNamespaces object (SBMLNamespace derived class
    //     for layout package. The class is basically used for createing an
    //     SBase derived objects belonging to the layout package) with the
    //     given SBML level, version.  (Package version is not required by
    //     Layout extension of SBML Level 2)
    //
    //        LayoutPkgNamespaces sbmlns(2, 3);
    //

    // create the document

    SBMLDocument *document = new SBMLDocument(&sbmlns);
    // create the Model

    Model* model = document->createModel();
    model->setId("TestModel_with_modifiers");
    document->setModel(model);

    // create the Layout

    LayoutPkgNamespaces layoutns(2, 3);

    LayoutModelPlugin* mplugin
        = static_cast<LayoutModelPlugin*>(model->getPlugin("layout"));
    Layout* layout = mplugin->createLayout();

    layout->setId("Layout_1");
    Dimensions dim(&layoutns, 400.0, 230.0);
    layout->setDimensions(&dim);


    // create the Compartment

    Compartment* compartment = model->createCompartment();
    compartment->setId("Yeast");

    // create the CompartmentGlyph

    CompartmentGlyph* compartmentGlyph = layout->createCompartmentGlyph();
    compartmentGlyph->setId("CompartmentGlyph_1");
    compartmentGlyph->setCompartmentId(compartment->getId());
    BoundingBox bb(&layoutns, "bb1", 5, 5, 390, 220);
    compartmentGlyph->setBoundingBox(&bb);

    // create the Species, SpeciesGlyphs and associated TextGlyphs

    // Glucose

    Species* species_Gluc = model->createSpecies();
    species_Gluc->setId("Glucose");
    species_Gluc->setCompartment(compartment->getId());

    SpeciesGlyph* glyph_Gluc = layout->createSpeciesGlyph();
    glyph_Gluc->setId("SpeciesGlyph_Glucose");
    glyph_Gluc->setSpeciesId(species_Gluc->getId());
    bb = BoundingBox(&layoutns, "bb2", 105, 20, 130, 20);
    glyph_Gluc->setBoundingBox(&bb);

    TextGlyph* tGlyph = layout->createTextGlyph();
    tGlyph->setId("TextGlyph_Glucose");
    bb = BoundingBox(&layoutns, "bbA", 115, 20, 110, 20);
    tGlyph->setBoundingBox(&bb);
    tGlyph->setOriginOfTextId(species_Gluc->getId());
    tGlyph->setGraphicalObjectId(glyph_Gluc->getId());

    // Glucose-6-phosphate

    Species* species_G6P = model->createSpecies();
    species_G6P->setId("Glucose_hyphen_6_hyphen_phosphate");
    species_G6P->setCompartment(compartment->getId());

    SpeciesGlyph* glyph_G6P = layout->createSpeciesGlyph();
    glyph_G6P->setId("SpeciesGlyph_G6P");
    glyph_G6P->setSpeciesId(species_G6P->getId());
    bb = BoundingBox(&layoutns, "bb5", 50, 190, 270, 20);
    glyph_G6P->setBoundingBox(&bb);

    tGlyph = layout->createTextGlyph();
    tGlyph->setId("TextGlyph_G6P");
    bb = BoundingBox(&layoutns, "bbD", 60, 190, 250, 20);
    tGlyph->setBoundingBox(&bb);
    tGlyph->setOriginOfTextId(species_G6P->getId());
    tGlyph->setGraphicalObjectId(glyph_G6P->getId());

    // ATP

    Species* species_ATP = model->createSpecies();
    species_ATP->setId("ATP");
    species_ATP->setCompartment(compartment->getId());

    SpeciesGlyph* glyph_ATP = layout->createSpeciesGlyph();
    glyph_ATP->setId("SpeciesGlyph_ATP");
    glyph_ATP->setSpeciesId(species_ATP->getId());
    bb = BoundingBox(&layoutns, "bb3", 270, 70, 80, 20);
    glyph_ATP->setBoundingBox(&bb);

    tGlyph = layout->createTextGlyph();
    tGlyph->setId("TextGlyph_ATP");
    bb = BoundingBox(&layoutns, "bbB", 280, 70, 60, 20);
    tGlyph->setBoundingBox(&bb);
    tGlyph->setOriginOfTextId(species_ATP->getId());
    tGlyph->setGraphicalObjectId(glyph_ATP->getId());

    // ADP

    Species* species_ADP = model->createSpecies();
    species_ADP->setId("ADP");
    species_ADP->setCompartment(compartment->getId());

    SpeciesGlyph* glyph_ADP = layout->createSpeciesGlyph();
    glyph_ADP->setId("glyph_ADP");
    glyph_ADP->setSpeciesId(species_ADP->getId());
    bb = BoundingBox(&layoutns, "bb4", 270, 140, 80, 20);
    glyph_ADP->setBoundingBox(&bb);

    tGlyph = layout->createTextGlyph();
    tGlyph->setId("TextGlyph_ADP");
    bb = BoundingBox(&layoutns, "bbC", 280, 140, 60, 20);
    tGlyph->setBoundingBox(&bb);
    tGlyph->setOriginOfTextId(species_ADP->getId());
    tGlyph->setGraphicalObjectId(glyph_ADP->getId());

    // Phosphate

    Species* species_Pi = model->createSpecies();
    species_Pi->setId("Pi");
    species_Pi->setCompartment(compartment->getId());

    SpeciesGlyph* glyph_Pi = layout->createSpeciesGlyph();
    glyph_Pi->setId("SpeciesGlyph_Pi");
    glyph_Pi->setSpeciesId(species_Pi->getId());
    bb = BoundingBox(&layoutns, "bb6", 50, 100, 60, 20);
    glyph_Pi->setBoundingBox(&bb);

    tGlyph = layout->createTextGlyph();
    tGlyph->setId("TextGlyph_PI");
    bb = BoundingBox(&layoutns, "bbE", 60, 100, 40, 20);
    tGlyph->setBoundingBox(&bb);
    tGlyph->setOriginOfTextId(species_Pi->getId());
    tGlyph->setGraphicalObjectId(glyph_Pi->getId());

    // create the Reaction

    Reaction* reaction_Hexokinase = model->createReaction();
    reaction_Hexokinase->setId("Hexokinase");
    reaction_Hexokinase->setReversible(false);

    ReactionGlyph* glyph_Hexokinase = layout->createReactionGlyph();
    glyph_Hexokinase->setId("glyph_Hexokinase");
    glyph_Hexokinase->setReactionId(reaction_Hexokinase->getId());

    Curve* curve_Hexokinase = glyph_Hexokinase->getCurve();
    LineSegment* ls = curve_Hexokinase->createLineSegment();
    Point p(&layoutns, 170, 100);
    ls->setStart(&p);
    p = Point(&layoutns, 170, 130);
    ls->setEnd(&p);

    // create the species reference for glucose

    SpeciesReference* reference_Gluc = reaction_Hexokinase->createReactant();
    reference_Gluc->setSpecies(species_Gluc->getId());
    reference_Gluc->setId("SpeciesReference_Glucose");

    // create species reference glyph for glucose

    SpeciesReferenceGlyph* speciesReferenceGlyph
        = glyph_Hexokinase->createSpeciesReferenceGlyph();
    speciesReferenceGlyph->setId("SpeciesReferenceGlyph_Glucose");
    speciesReferenceGlyph->setSpeciesGlyphId(glyph_Gluc->getId());
    speciesReferenceGlyph->setSpeciesReferenceId(reference_Gluc->getId());
    speciesReferenceGlyph->setRole(SPECIES_ROLE_SUBSTRATE);

    ls = speciesReferenceGlyph->createLineSegment();
    p = Point(&layoutns, 170, 100);
    ls->setStart(&p);
    p = Point(&layoutns, 170, 50);
    ls->setEnd(&p);

    // create species reference for ATP

    SpeciesReference* reference_ATP
        = reaction_Hexokinase->createReactant();
    reference_ATP->setSpecies(species_ATP->getId());
    reference_ATP->setId("SpeciesReference_ATP");

    // create the species reference glyph for ATP

    speciesReferenceGlyph = glyph_Hexokinase->createSpeciesReferenceGlyph();
    speciesReferenceGlyph->setId("SpeciesReferenceGlyph_ATP");
    speciesReferenceGlyph->setSpeciesGlyphId(glyph_ATP->getId());
    speciesReferenceGlyph->setSpeciesReferenceId(reference_ATP->getId());
    speciesReferenceGlyph->setRole(SPECIES_ROLE_SIDESUBSTRATE);

    CubicBezier* cb = speciesReferenceGlyph->createCubicBezier();
    p = Point(&layoutns, 170, 100);
    cb->setStart(&p);
    p = Point(&layoutns, 170, 80);
    cb->setBasePoint1(&p);
    p = Point(&layoutns, 170, 80);
    cb->setBasePoint2(&p);
    p = Point(&layoutns, 260, 80);
    cb->setEnd(&p);

    // create species reference for G6P

    SpeciesReference* reference_G6P = reaction_Hexokinase->createProduct();
    reference_G6P->setSpecies(species_G6P->getId());
    reference_G6P->setId("SpeciesReference_G6P");

    // create species reference for G6P as product

    speciesReferenceGlyph = glyph_Hexokinase->createSpeciesReferenceGlyph();
    speciesReferenceGlyph->setId("SpeciesReferenceGlyph_G6P_1");
    speciesReferenceGlyph->setSpeciesGlyphId(glyph_G6P->getId());
    speciesReferenceGlyph->setSpeciesReferenceId(reference_G6P->getId());
    speciesReferenceGlyph->setRole(SPECIES_ROLE_PRODUCT);

    ls = speciesReferenceGlyph->createLineSegment();
    p = Point(&layoutns, 170, 130);
    ls->setStart(&p);
    p = Point(&layoutns, 170, 180);
    ls->setEnd(&p);

    // create species reference for ADP

    SpeciesReference* reference_ADP = reaction_Hexokinase->createProduct();
    reference_ADP->setSpecies(species_ADP->getId());
    reference_ADP->setId("SpeciesReference_ADP");

    // create the species reference glyph for ADP

    speciesReferenceGlyph = glyph_Hexokinase->createSpeciesReferenceGlyph();
    speciesReferenceGlyph->setId("SpeciesReferenceGlyph_ADP");
    speciesReferenceGlyph->setSpeciesGlyphId(glyph_ADP->getId());
    speciesReferenceGlyph->setSpeciesReferenceId(reference_ADP->getId());
    speciesReferenceGlyph->setRole(SPECIES_ROLE_SIDEPRODUCT);

    cb = speciesReferenceGlyph->createCubicBezier();
    p = Point(&layoutns, 170, 130);
    cb->setStart(&p);
    p = Point(&layoutns, 170, 150);
    cb->setBasePoint1(&p);
    p = Point(&layoutns, 170, 150);
    cb->setBasePoint2(&p);
    p = Point(&layoutns, 260, 150);
    cb->setEnd(&p);

    // create modifier species reference for glucose-6-phosphate

    ModifierSpeciesReference* reference_G6P_2
        = reaction_Hexokinase->createModifier();
    reference_G6P_2->setSpecies(species_G6P->getId());
    reference_G6P_2->setId("ModifierSpeciesReference_G6P");

    reaction_Hexokinase->addModifier(reference_G6P_2);

    // create species reference glyph for G6P as a modifier

    speciesReferenceGlyph = glyph_Hexokinase->createSpeciesReferenceGlyph();
    speciesReferenceGlyph->setId("SpeciesReferenceGlyph_G6P_2");
    speciesReferenceGlyph->setSpeciesReferenceId(reference_G6P_2->getId());
    speciesReferenceGlyph->setSpeciesGlyphId(glyph_G6P->getId());
    speciesReferenceGlyph->setRole(SPECIES_ROLE_INHIBITOR);

    cb = speciesReferenceGlyph->createCubicBezier();
    p = Point(&layoutns, 45, 200);
    cb->setStart(&p);
    p = Point(&layoutns, 0, 200);
    cb->setBasePoint1(&p);
    p = Point(&layoutns, 0, 120);
    cb->setBasePoint2(&p);
    p = Point(&layoutns, 165, 120);
    cb->setEnd(&p);

    // create modifier species reference for phosphate

    ModifierSpeciesReference* reference_Pi = reaction_Hexokinase->createModifier();
    reference_Pi->setSpecies(species_Pi->getId());
    reference_Pi->setId("ModifierSpeciesReference_Pi");

    reaction_Hexokinase->addModifier(reference_Pi);

    // create the species reference glyph for Phosphate

    speciesReferenceGlyph = glyph_Hexokinase->createSpeciesReferenceGlyph();
    speciesReferenceGlyph->setId("SpeciesReferenceGlyph_PI");
    speciesReferenceGlyph->setSpeciesReferenceId(reference_Pi->getId());
    speciesReferenceGlyph->setSpeciesGlyphId(glyph_Pi->getId());
    speciesReferenceGlyph->setRole(SPECIES_ROLE_ACTIVATOR);

    cb = speciesReferenceGlyph->createCubicBezier();
    p = Point(&layoutns, 115, 110);
    cb->setStart(&p);
    p = Point(&layoutns, 140, 110);
    cb->setBasePoint1(&p);
    p = Point(&layoutns, 140, 110);
    cb->setBasePoint2(&p);
    p = Point(&layoutns, 165, 110);
    cb->setEnd(&p);

    // write model to file

    writeSBML(document, "layout_example3_L2.xml");
    delete document;

}
Example #25
0
SD_API_STATUS 
CSDHCBase::SlotOptionHandler(
                             DWORD                 dwSlot, 
                             SD_SLOT_OPTION_CODE   sdOption, 
                             PVOID                 pData,
                             DWORD                 cbData
                             )
{
    SD_API_STATUS   status = SD_API_STATUS_SUCCESS;
    BOOL            fCallSlotsHandler = TRUE;

    Lock();
    Validate();
    PCSDHCSlotBase pSlot = GetSlot(dwSlot);

    DEBUGCHK(sdOption < dim(sc_rgpszOptions));
    DEBUGCHK(sc_rgpszOptions[sdOption] != NULL);
    DEBUGMSG(SDCARD_ZONE_INFO, (_T("CSDHCBase::SlotOptionHandler(%u, %s)\n"),
        dwSlot, sc_rgpszOptions[sdOption]));

    switch (sdOption) {
    case SDHCDSetSlotPower: {
        if (cbData != sizeof(DWORD)) {
            status = SD_API_STATUS_INVALID_PARAMETER;
        }
        break;
    }

    case SDHCDSetSlotInterface: {
        if (cbData != sizeof(SD_CARD_INTERFACE)) {
            status = SD_API_STATUS_INVALID_PARAMETER;
        }
        break;
    }

    case SDHCDEnableSDIOInterrupts:
    case SDHCDDisableSDIOInterrupts:
    case SDHCDAckSDIOInterrupt:
        if (pData || cbData != 0) {
            status = SD_API_STATUS_INVALID_PARAMETER;
        }
        break;

    case SDHCDGetWriteProtectStatus: {
        if (cbData != sizeof(SD_CARD_INTERFACE)) {
            status = SD_API_STATUS_INVALID_PARAMETER;
        }
        break;
    }

    case SDHCDQueryBlockCapability: {
        if (cbData != sizeof(SD_HOST_BLOCK_CAPABILITY)) {
            status = SD_API_STATUS_INVALID_PARAMETER;
        }
        break;
    }

    case SDHCDSetSlotPowerState: {
        if (cbData != sizeof(CEDEVICE_POWER_STATE)) {
            status = SD_API_STATUS_INVALID_PARAMETER;
        }

        PCEDEVICE_POWER_STATE pcps = (PCEDEVICE_POWER_STATE) pData;

        if (*pcps < m_cpsCurrent) {
            // Move controller to higher power state initially since
            // it will need to be powered for the slot to access
            // registers.
            SetControllerPowerState(*pcps);
        }

        status = pSlot->SlotOptionHandler(sdOption, pData, cbData);

        // Set the power state based on current conditions. Note that 
        // the slot may have gone to a state different from what was 
        // requested.
        CEDEVICE_POWER_STATE cps = DetermineRequiredControllerPowerState();
        SetControllerPowerState(cps);
        fCallSlotsHandler = FALSE;
        break;
    }

    case SDHCDGetSlotPowerState: {
        if (cbData != sizeof(CEDEVICE_POWER_STATE)) {
            status = SD_API_STATUS_INVALID_PARAMETER;
        }
        break;
    }

    case SDHCDWakeOnSDIOInterrupts: {
        if (cbData != sizeof(BOOL)) {
            status = SD_API_STATUS_INVALID_PARAMETER;
        }
        break;
    }

    case SDHCDGetSlotInfo: {
        if (cbData != sizeof(SDCARD_HC_SLOT_INFO)) {
            status = SD_API_STATUS_INVALID_PARAMETER;
        }
        break;
    }

    default:
        break;
    }

    if (SD_API_SUCCESS(status) && fCallSlotsHandler) {
        // Call the slots handler to do the real work.
        status = pSlot->SlotOptionHandler(sdOption, pData, cbData);
    }

    Unlock();

    return status;
}
Example #26
0
// This routine reads the registry to determine what type of device interfaces
// we will be monitoring.  The default PM GUID is ignored if present in the
// registry and is always added last (so it's first in the list).
BOOL
DeviceListsInit(VOID)
{
    BOOL fOk = TRUE;
    PDEVICE_LIST pdl;
    DWORD dwStatus;
    HKEY hk;
    TCHAR szBuf[MAX_PATH];

#ifndef SHIP_BUILD
    SETFNAME(_T("DeviceListsInit"));
#endif 

    // enumerate all the device classes
    StringCchPrintf(szBuf,_countof(szBuf), _T("%s\\Interfaces"), PWRMGR_REG_KEY);
    dwStatus = RegOpenKeyEx(HKEY_LOCAL_MACHINE, szBuf, 0, 0, &hk);
    if(dwStatus == ERROR_SUCCESS) {
        DWORD dwIndex = 0;
        do {
            DWORD cbValueName = dim(szBuf), dwType;
            GUID idInterface;

            dwStatus = RegEnumValue(hk, dwIndex, szBuf, &cbValueName, NULL,
                &dwType, NULL, NULL);
            if(dwStatus == ERROR_SUCCESS) {
                if(dwType != REG_SZ) {
                    PMLOGMSG(ZONE_WARN, (_T("%s: invalid type for value '%s'\r\n"),
                        pszFname, szBuf));
                } else if(!ConvertStringToGuid(szBuf, &idInterface)) {
                    PMLOGMSG(ZONE_WARN, (_T("%s: can't convert '%s' to GUID\r\n"),
                        pszFname, szBuf));
                } else if(idInterface == idGenericPMDeviceClass) {
                    PMLOGMSG(ZONE_INIT, (_T("%s: default GUID found in registry as expected\r\n"), 
                        pszFname));
                } else if((pdl = DeviceListCreate(&idInterface)) == NULL) {
                    PMLOGMSG(ZONE_WARN, (_T("%s: DeviceListCreate() failed\r\n"), 
                        pszFname));
                } else if(PlatformDeviceListInit(pdl) == FALSE) {
                    PMLOGMSG(ZONE_WARN, (_T("%s: PlatformDeviceListInit() failed\r\n"), 
                        pszFname));
                    DeviceListDestroy(pdl);
                } else {
                    // add the new entry to the list
                    pdl->pNext = gpDeviceLists;
                    gpDeviceLists = pdl;
                }

                // update the index
                dwIndex++;
            }
        } while(dwStatus == ERROR_SUCCESS);

        // check for abnormal termination of the loop
        if(dwStatus != ERROR_NO_MORE_ITEMS) {
            fOk = FALSE;
        }

        // close the registry handle
        RegCloseKey(hk);
    }

    // add the default list last
    if(fOk) {
        fOk = FALSE;
        pdl = DeviceListCreate(&idGenericPMDeviceClass);
        if(pdl != NULL) {
            if(PlatformDeviceListInit(pdl) == FALSE) {
                PMLOGMSG(ZONE_INIT || ZONE_WARN, 
                    (_T("%s: PlatformDeviceListInit() failed for default class\r\n"),
                    pszFname));
                DeviceListDestroy(pdl);
            } else {
                pdl->pNext = gpDeviceLists;
                gpDeviceLists = pdl;
                fOk = TRUE;
            }
        }
    }

    // clean up if necessary
    if(!fOk) {
        PMLOGMSG(ZONE_WARN, (_T("%s: error during list initialization\r\n"), 
            pszFname));
        while(gpDeviceLists != NULL) {
            pdl = gpDeviceLists;
            gpDeviceLists = pdl->pNext;
            pdl->pNext = NULL;
            DeviceListDestroy(pdl);
        }
    }

    return fOk;
}
Example #27
0
void gsMapper::drawMap(v3s16 position)
{
	// width and height in nodes (these don't really need to be exact)
	s16 nwidth = floor(d_width / d_scale);
	s16 nheight = floor(d_height / d_scale);

	bool hasChanged = false;

	// check if position is outside the center
	if (d_valid)
	{
		if ( (position.X - d_border) < d_origin.X ||
			(position.Z - d_border) < d_origin.Z ||
			(position.X + d_border) > (d_origin.X + nwidth) ||
			(position.Z + d_border) > (d_origin.Z + nheight) ) d_valid = false;
	}

	// recalculate the origin
	if (!d_valid || d_tracking)
	{
		d_origin.X = floor(position.X - (nwidth / 2));
		d_origin.Y = d_surface;
		d_origin.Z = floor(position.Z - (nheight / 2));
		d_valid = true;
		hasChanged = true;
	}

	// rescan next division of the map
	Map &map = d_client->getEnv().getMap();
	v3s16 p;
	s16 x = 0;
	s16 y = 0;
	s16 z = 0;

	while (z < (nheight / 8) && (z + d_scanZ) < nheight)
	{
		p.Z = d_origin.Z + z + d_scanZ;
		x = 0;
		while (x < (nwidth / 8) && (x + d_scanX) < nwidth)
		{
			p.X = d_origin.X + x + d_scanX;
			bool b = true;

			// "above" mode: surface = mid-point for scanning
			if (d_above)
			{
				p.Y = d_surface + (d_scan / 2);
				for (y = 0; y < d_scan; y++)
				{
					if (b)
					{
						MapNode n = map.getNodeNoEx(p);
						p.Y--;
						if (n.param0 != CONTENT_IGNORE && n.param0 != CONTENT_AIR)
						{
							b = false;
							p.Y = d_surface;

							// check to see if this node is different from the map
							std::map<v3s16, u16>::iterator i2 = d_map.find(p);
							if ( i2 == d_map.end() ||
								(i2 != d_map.end() && n.param0 != d_map[p]) )
							{
								hasChanged = true;
								d_map[p] = n.param0;	// change it
							}
						}
					}
				}

			// not "above" = use the radar for mapping
			} else {
				p.Y = position.Y + 1;
				MapNode n = map.getNodeNoEx(p);
				bool w = (n.param0 != CONTENT_IGNORE && n.param0 != CONTENT_AIR);

				int count = 0;
				u16 id = CONTENT_AIR;
				while (b)
				{
					if (w)		// wall = scan up for air
					{
						p.Y++;
						n = map.getNodeNoEx(p);
						if (n.param0 == CONTENT_AIR)
							b = false;
						else
							id = n.param0;

					} else {	// not wall = scan down for non-air
						p.Y--;
						n = map.getNodeNoEx(p);
						if (n.param0 != CONTENT_IGNORE && n.param0 != CONTENT_AIR)
						{
							id = n.param0;
							b = false;
						}
					}
					if (b && count++ >= (d_scan / 8)) 
					{
						b = false;
						id = CONTENT_AIR;
					}
				}

				p.Y = d_surface;		// the data is always flat
				std::map<v3s16, u16>::iterator i5 = d_radar.find(p);
				if ( i5 == d_radar.end() ||
					(i5 != d_radar.end() && id != d_radar[p]) )
				{
					hasChanged = true;
					d_radar[p] = id;	// change it
				}
			}
			x++;
		}
		z++;
	}

	// move the scan block
	d_scanX += (nwidth / 8);
	if (d_scanX >= nwidth)
	{
		d_scanX = 0;
		d_scanZ += (nheight / 8);
		if (d_scanZ >= nheight)	d_scanZ = 0;
	}

	video::IVideoDriver *driver = d_device->getVideoDriver();

	if (hasChanged || !d_hastex)
	{
		// set up the image
		core::dimension2d<u32> dim(nwidth, nheight);
		video::IImage *image = driver->createImage(video::ECF_A8R8G8B8, dim);
		assert(image);

		bool psum = false;
		for (z = 0; z < nheight; z++)
		{
			for (x = 0; x < nwidth; x++)
			{
				p.X = d_origin.X + x;
				p.Y = d_surface;
				p.Z = d_origin.Z + z;

				u16 i = CONTENT_IGNORE;
				if (d_above)
				{
					std::map<v3s16, u16>::iterator i3 = d_map.find(p);
					if (i3 != d_map.end()) i = d_map[p];
				} else {
					std::map<v3s16, u16>::iterator i6 = d_radar.find(p);
					if (i6 != d_radar.end()) i = d_radar[p];
				}

				video::SColor c = getColorFromId(i);
				c.setAlpha(d_alpha);
				image->setPixel(x, nheight - z - 1, c);
				if (i != CONTENT_IGNORE) psum = true;
			}
		}

		// image -> texture
		if (psum && d_cooldown2 == 0)
		{
			if (d_hastex)
			{
				driver->removeTexture(d_texture);
				d_hastex = false;
			}
			std::string f = "gsmapper__" + itos(d_device->getTimer()->getRealTime());
			d_texture = driver->addTexture(f.c_str(), image);
			assert(d_texture);
			d_hastex = true;
			d_cooldown2 = 5;	// don't generate too many textures all at once
		} else {
			d_cooldown2--;
			if (d_cooldown2 < 0) d_cooldown2 = 0;
		}

		image->drop();
	} 

	// draw map texture
	if (d_hastex) {
		driver->draw2DImage( d_texture,
			core::rect<s32>(d_posx, d_posy, d_posx+d_width, d_posy+d_height),
			core::rect<s32>(0, 0, nwidth, nheight),
			0, 0, true );
	}

	// draw local player marker
	if (d_tsrc->isKnownSourceImage("player_marker0.png"))
	{
		v3s16 p = floatToInt(d_player->getPosition(), BS);
		if ( p.X >= d_origin.X && p.X <= (d_origin.X + nwidth) &&
			p.Z >= d_origin.Z && p.Z <= (d_origin.Z + nheight) )
		{
			f32 y = floor(360 - wrapDegrees_0_360(d_player->getYaw()));
			if (y < 0) y = 0;
			int r = floor(y / 90.0);
			int a = floor(fmod(y, 90.0) / 10.0);
			std::string f = "player_marker" + itos(a) + ".png";
			video::ITexture *pmarker = d_tsrc->getTexture(f);
			assert(pmarker);
			v2u32 size = pmarker->getOriginalSize();

			if (r > 0)
			{
				core::dimension2d<u32> dim(size.X, size.Y);
				video::IImage *image1 = driver->createImage(pmarker,
					core::position2d<s32>(0, 0), dim);
				assert(image1);

				// rotate image
				video::IImage *image2 = driver->createImage(video::ECF_A8R8G8B8, dim);
				assert(image2);
				for (u32 y = 0; y < size.Y; y++)
				for (u32 x = 0; x < size.X; x++)
				{
					video::SColor c;
					if (r == 1)
					{
						c = image1->getPixel(y, (size.X - x - 1));
					} else if (r == 2) {
						c = image1->getPixel((size.X - x - 1), (size.Y - y - 1));
					} else {
						c = image1->getPixel((size.Y - y - 1), x);
					}
					image2->setPixel(x, y, c);
				}
				image1->drop();
				if (d_hasptex)
				{
					driver->removeTexture(d_pmarker);
					d_hasptex = false;
				}
				d_pmarker = driver->addTexture("playermarker__temp__", image2);
				assert(d_pmarker);
				pmarker = d_pmarker;
				d_hasptex = true;
				image2->drop();
			}

			s32 sx = d_posx + floor((p.X - d_origin.X) * d_scale) - (size.X / 2);
			s32 sy = d_posy + floor((nheight - (p.Z - d_origin.Z)) * d_scale) - (size.Y / 2);
			driver->draw2DImage( pmarker,
				core::rect<s32>(sx, sy, sx+size.X, sy+size.Y),
				core::rect<s32>(0, 0, size.X, size.Y),
				0, 0, true );
		}
	}
}
Example #28
0
// This routine initializes the power manager and notifies the system that
// its api set is ready to be used.  It returns TRUE if successful and FALSE
// if there's a problem.
EXTERN_C BOOL WINAPI
PmInit(VOID)
{
    BOOL fOk = TRUE;
    HANDLE hevPnPReady = NULL, hevResumeReady = NULL, hevSystemReady = NULL;
    HANDLE hevActivityTimersReady = NULL, hevDummy = NULL;

#ifndef SHIP_BUILD
    SETFNAME(_T("PmInit"));
#endif

    PMLOGMSG(ZONE_INIT || ZONE_API, (_T("+%s\r\n"), pszFname));

    // set up globals
    InitializeCriticalSection(&gcsPowerManager);
    InitializeCriticalSection(&gcsDeviceUpdateAPIs);
    gpFloorDx = NULL;
    gpCeilingDx = NULL;
    gpPowerNotifications = NULL;
    gpSystemPowerState = NULL;
    ghPmHeap = GetProcessHeap();
    gpDeviceLists = NULL;
    gppActivityTimers = NULL;
    ghevPowerManagerReady = NULL;
    ghevResume = NULL;
    ghevTimerResume = NULL;
    ghtPnP = NULL;
    ghtResume = NULL;
    ghtActivityTimers = NULL;
    ghtSystem = NULL;

    // cleanup event (hopefully never used)
    ghevPmShutdown = CreateEvent(NULL, TRUE, FALSE, NULL);
    if(ghevPmShutdown == NULL) {
        PMLOGMSG(ZONE_ERROR, (_T("%s: CreateEvent() failed for shutdown event\r\n"), pszFname));
        fOk = FALSE;
    } 

    // validate the power management registry settings.  OEM code should use this
    // routine to make sure that registry settings are present for all the power
    // states they expect to support.  If the registry is not configured, the OEM
    // code can treat it as a fatal error or perform its own initialization.
    if(fOk) {
        DWORD dwStatus = PlatformValidatePMRegistry();
        if(dwStatus != ERROR_SUCCESS) {
            PMLOGMSG(ZONE_ERROR, (_T("%s: PlatformValidatePMRegistry() failed %d\r\n"), 
                pszFname, dwStatus));
            fOk = FALSE;
        } else {
            // read the list of interface types we will monitor
            fOk = DeviceListsInit();
        }
    }

    // create events
    if(fOk) {
        ghevPowerManagerReady = CreateEvent(NULL, TRUE, FALSE, _T("SYSTEM/PowerManagerReady"));
        ghevResume = CreateEvent(NULL, FALSE, FALSE, NULL);
        ghevTimerResume = CreateEvent(NULL, FALSE, FALSE, NULL);
        hevPnPReady = CreateEvent(NULL, FALSE, FALSE, NULL);
        hevResumeReady = CreateEvent(NULL, FALSE, FALSE, NULL);
        hevSystemReady = CreateEvent(NULL, FALSE, FALSE, NULL);
        hevActivityTimersReady = CreateEvent(NULL, FALSE, FALSE, NULL);
        hevDummy = CreateEvent(NULL, FALSE, FALSE, NULL);

        // check everything
        if(hevPnPReady == NULL
        || hevResumeReady == NULL 
        || hevSystemReady == NULL
        || hevActivityTimersReady == NULL
        || hevDummy == NULL
        || ghevPowerManagerReady == NULL
        || ghevTimerResume == NULL
        || ghevResume == NULL) {
            PMLOGMSG(ZONE_ERROR, (_T("%s: event creation failure\r\n"), pszFname));
            fOk = FALSE;
        }
    }

    // start threads
    if(fOk) {
        ghtPnP = CreateThread(NULL, 0, PnpThreadProc, (LPVOID) hevPnPReady, 0, NULL);
        ghtResume = CreateThread(NULL, 0, ResumeThreadProc, (LPVOID) hevResumeReady, 0, NULL);
        ghtActivityTimers = CreateThread(NULL, 0, ActivityTimersThreadProc, 
            (LPVOID) hevActivityTimersReady, 0, NULL);
        
        // check everything
        if(ghtPnP == NULL 
        || ghtResume == NULL 
        || ghtActivityTimers == NULL) {
            PMLOGMSG(ZONE_ERROR, (_T("%s: thread creation failure\r\n"), pszFname));
            fOk = FALSE;
        }
    }

    // wait for threads to initialize (or fail to initialize)
    #define NUM_OF_READY_EXIT_PAIR 3
    HANDLE hEvents[] = { hevPnPReady, hevResumeReady, hevActivityTimersReady, 
        ghtPnP, ghtResume, ghtActivityTimers };
    int iReady = 0;
    while( iReady < NUM_OF_READY_EXIT_PAIR  && fOk) {
        DWORD dwStatus = WaitForMultipleObjects(dim(hEvents), hEvents, FALSE, INFINITE);
        switch(dwStatus) {
        // thread ready events
        case (WAIT_OBJECT_0 + 0):   // pnp ready
        case (WAIT_OBJECT_0 + 1):   // resume ready
        case (WAIT_OBJECT_0 + 2):   // activity timers ready
            // don't watch for the thread exiting now -- some may do
            // so if they don't have work to do.
            hEvents[dwStatus - WAIT_OBJECT_0 + NUM_OF_READY_EXIT_PAIR] = hevDummy;
            iReady++;
            break;

        // thread exiting events
        case (WAIT_OBJECT_0 + 3):   // pnp exited
        case (WAIT_OBJECT_0 + 4):   // resume exited
        case (WAIT_OBJECT_0 + 5):   // activity timers exited
            PMLOGMSG(ZONE_ERROR, (_T("%s: thread initialization failure\r\n"), pszFname));
            fOk = FALSE;
            break;
        default:
            PMLOGMSG(ZONE_ERROR, (_T("%s: WaitForMultipleObjects() returnd %d, status is %d\r\n"),
                pszFname, GetLastError()));
            fOk = FALSE;
            break;
        }
    }

    // load PMExt DLL, call init
    if (fOk) {
        TCHAR DevDll[DEVDLL_LEN];
        DWORD cbData;
        DWORD Flags;
        HKEY hKey;

        gpPMExtInit = NULL;
        gpPMExtDeinit = NULL;;

        // Note: TEXT("\\Omap") is appended to the PMExt_Registry_Root because this is the only PMExt that we support
        if (ERROR_SUCCESS == RegOpenKeyEx(HKEY_LOCAL_MACHINE, PMExt_Registry_Root TEXT("\\Omap"), 0, 0, &hKey)) {
            cbData = sizeof(DevDll);
            if (ERROR_SUCCESS == RegQueryValueEx(hKey, DEVLOAD_DLLNAME_VALNAME, NULL, NULL, (LPBYTE) DevDll, &cbData)) {
                cbData = sizeof(Flags);
                if (ERROR_SUCCESS != RegQueryValueEx(hKey, DEVLOAD_FLAGS_VALNAME, NULL, NULL, (LPBYTE) &Flags, &cbData)) {
                    Flags = DEVFLAGS_NONE;
                }
                ghPMExtLib = (Flags & DEVFLAGS_LOADLIBRARY) ? LoadLibrary(DevDll) : LoadDriver(DevDll);
                if (!ghPMExtLib) {
                    PMLOGMSG(ZONE_ERROR, (_T("%s: couldn't load PMExt \"%s\" -- error %d\r\n"), pszFname, DevDll, GetLastError()));
                } 
                else {
                    gpPMExtInit = (PFN_PMExt_Init) GetProcAddress(ghPMExtLib, PMExt_Init_NAME);
                    if (!gpPMExtInit)
                        PMLOGMSG(ZONE_ERROR, (_T("%s: \"%s\" can't GetProcAddress\r\n"), pszFname, PMExt_Init_NAME));

                    gpPMExtDeinit = (PFN_PMExt_DeInit) GetProcAddress(ghPMExtLib, PMExt_DeInit_NAME);
                }
            }
            else {
                PMLOGMSG(ZONE_INIT, (_T("%s: can't get value \"%s\" in key \"%s\"\r\n"), pszFname, DEVLOAD_DLLNAME_VALNAME, PMExt_Registry_Root TEXT("\\Omap")));
            }
            if (gpPMExtInit && gpPMExtDeinit) {
#ifdef DEBUG
               gdwPMExtContext = gpPMExtInit(HKEY_LOCAL_MACHINE, PMExt_Registry_Root TEXT("\\Omap"));
#else
                __try {
                    gdwPMExtContext = gpPMExtInit(HKEY_LOCAL_MACHINE, PMExt_Registry_Root TEXT("\\Omap"));
                }
                __except(EXCEPTION_EXECUTE_HANDLER) {
                    gdwPMExtContext = 0;
                }
#endif
                if (!gdwPMExtContext)
                    PMLOGMSG(ZONE_ERROR, (_T("%s: \"%s\" failed\r\n"), pszFname, PMExt_Init_NAME));
                else
                    PMLOGMSG(ZONE_INIT, (_T("%s: \"%s\" success\r\n"), pszFname, PMExt_Init_NAME));
            }
            RegCloseKey(hKey);
        }
 const SpdMatrix & IMMGS::siginv() const {
   sigma_scratch_.resize(dim());
   sigma_scratch_.diag() = 1.0 / unscaled_variance_diagonal();
   sigma_scratch_.diag() /= sigsq();
   return sigma_scratch_;
 }
Example #30
0
	static constexpr int size() {
		return Sequence::size() / (1 << dim());
	}