int any(char s1[], char s2[]) {
int i, j;
int loc = -1;
for(i = 0; s2[i] != '\0'; i++) {
loc = findLoc(s1, s2[i]);
if(loc != -1)
return loc;
}
return loc;
}
/**
* 多面体データから distance field VolumeDataへの変換
* @param w Width
* @param h Height
* @param d Depth
* @retval true 変換成功
* @retval false 変換失敗
*/
bool SolidDfToVolume::ToVolume(int w, int h, int d) {
m_volume = BufferVolumeData::CreateInstance();
int c = 1; // Store scalar density.
m_volume->Create(w, h, d, c);
// assert(m_solid);
// assert(m_solid->Position());
// assert(m_solid->Position()->GetNum() > 0);
float* voxels = m_volume->Buffer()->GetBuffer();
const size_t fnum = w * h * d * c;
for (size_t i = 0; i < fnum; i++) {
voxels[i] = 0.0f; //-FLT_MAX; // @fixme
}
std::vector<int> countBuf(w * h * d, 0); // for compute avarage.
float *position = m_solid->Position()->GetBuffer();
size_t dim[3] = { w, h, d };
float scale[3] = { (m_bmax[0] - m_bmin[0])/w, (m_bmax[1] - m_bmin[1])/h, (m_bmax[2] - m_bmin[2])/d };
const int solid_n = m_solid->Position()->GetNum()/m_solid->GetType();
const int solid_type = m_solid->GetType();
std::vector<Solid> solids;
solids.reserve(solid_n);
for (int i = 0; i < solid_n; i++) {
solids.push_back( Solid(position + solid_type * 3 * i, solid_type));
}
BVH bvh;
bvh.generateBvhTree(solids);
for (float x = m_bmin[0], y, z; x < m_bmax[0]; x += scale[0])
for (y = m_bmin[1]; y < m_bmax[1]; y += scale[1])
for (z = m_bmin[2]; z < m_bmax[2]; z += scale[2])
{
VX::Math::vec3 pt(x, y, z);
float d = 1e16;
bvh.searchNearestSolid(pt, d, 0);
voxels[findLoc(x, y, z, m_bmin, m_bmax, dim)] = d;
}
printf("ToVolume: %zu, %zu, %zu\n", dim[0], dim[1], dim[2]);
return true;
}
/**
* 点データからVolumeDataへの変換
* @param w Width
* @param h Height
* @retval true 変換成功
* @retval false 変換失敗
*/
bool PointToVolume::ToVolume(int w, int h, int d) {
m_volume = BufferVolumeData::CreateInstance();
int c = 1; // Store scalar density.
m_volume->Create(w, h, d, c);
FloatBuffer* buffer = m_volume->Buffer();
float bmin[3];
float bmax[3];
assert(m_point);
assert(m_point->Position());
assert(m_point->Position()->GetNum() > 0);
// Compute bounding box.
float *position = m_point->Position()->GetBuffer();
bmin[0] = bmax[0] = position[0];
bmin[1] = bmax[1] = position[1];
bmin[2] = bmax[2] = position[2];
for (size_t i = 1; i < m_point->Position()->GetNum(); i++) {
bmin[0] = (std::min)(bmin[0], position[3*i+0]);
bmin[1] = (std::min)(bmin[1], position[3*i+1]);
bmin[2] = (std::min)(bmin[2], position[3*i+2]);
bmax[0] = (std::max)(bmax[0], position[3*i+0]);
bmax[1] = (std::max)(bmax[1], position[3*i+1]);
bmax[2] = (std::max)(bmax[2], position[3*i+2]);
}
printf("bmin: %f, %f, %f\n", bmin[0], bmin[1], bmin[2]);
printf("bmax: %f, %f, %f\n", bmax[0], bmax[1], bmax[2]);
float* voxels = m_volume->Buffer()->GetBuffer();
const size_t fnum = w * h * d * c;
memset(voxels, 0, fnum * sizeof(float));
// @todo { Consider particle radius. }
size_t dim[3] = { w, h, d };
for (size_t i = 1; i < m_point->Position()->GetNum(); i++) {
size_t loc = findLoc(position[3*i+0], position[3*i+1], position[3*i+2], bmin, bmax, dim);
voxels[loc] += 1.0f;
}
printf("ToVolume: %zu, %zu, %zu\n", dim[0], dim[1], dim[2]);
return true;
}
void * mymalloc(int size, char * file, int line ){
static int initialized = 0;
static int l_in = 0;
static int total = 500;
MemEntryPtr p, succ, pre;
if(size<40){
if (initialized==0 && l_in==0) {
int i =0;
for (i=0; i<500; i++) {
BIGBLOCK[i] = '\0';
}
printf("BigBlock: %p\n", BIGBLOCK);
lroot = (MemEntryPtr) BIGBLOCK;
lroot->prev = lroot->succ = 0;
lroot->size = BLOCKSIZE - (int)sizeof(MemEntry);
mid = 500-sizeof(MemEntry);
lroot->isFree = 1;
initialized = 1;
total = 500-sizeof(MemEntry);
sizeptr = lroot;
lsiz = lroot;
}
if (initialized==0 && l_in!=0) {
lroot = (MemEntryPtr) BIGBLOCK;
lroot->prev = lroot->succ = 0;
int x = rsiz->size;
lroot->size = x-sizeof(MemEntry);
lroot->isFree = 1;
initialized = 1;
sizeptr->size -= sizeof(MemEntry);
rsiz = sizeptr;
sizeptr = lroot;
lsiz = lroot;
}
p = lroot;
p = (MemEntryPtr)findLoc(p, 0);
while(1){
if (p==0) {
printf("Not enough memory to fill that request <100\n");
printf("%p\n", sizeptr);
return NULL;
}
if (p->size<size) {
p = p->succ;
}
else if(p->size < (size + sizeof(MemEntry))){
p->isFree = 0;
if (p->succ == 0) {
sizeptr = p;
if (l_in!=0) {
rsiz->size = 0;
}
}
printf("%p SIZE LEFT: %d\n", p, sizeptr->size);
p->a=126;
return (char*) p + sizeof(MemEntry);
}
else{
succ = (MemEntry*) ((char *) p + sizeof(MemEntry) + size);
succ-> prev = p;
succ-> succ = p->succ;
if(p->succ!=0){
p->succ->prev = succ;
}
succ->size = p->size - (int)sizeof(MemEntry) - size;
if (p->succ == 0) {
sizeptr = succ;
if(l_in!=0){
rsiz->size = sizeptr->size;
}
lsiz = sizeptr;
}
p-> succ = succ;
succ->isFree = 1;
p-> size = size;
p->isFree = 0;
printf("%p SIZE LEFT: %d\n", p, sizeptr->size);
p->a=126;
return (char *)p + sizeof(struct MemEntry);
}
p = (MemEntryPtr)findLoc(p, 0);
}
}
else{
if (initialized==0 && l_in==0) {
int i =0;
for (i=0; i<500; i++) {
BIGBLOCK[i] = '\0';
}
rroot = (MemEntryPtr)&(BIGBLOCK[476]) ;
rroot->prev = rroot->succ = 0;
rroot->size = BLOCKSIZE - sizeof(MemEntry);
rroot->isFree = 1;
l_in = 1;
sizeptr = rroot;
rsiz = sizeptr;
printf("%p\n", rroot);}
if (l_in==0 && initialized!=0) {
rroot = (MemEntryPtr)&(BIGBLOCK[476]) ;
rroot->prev = rroot->succ = 0;
int q = sizeptr->size;
rroot->size = q-(int)sizeof(MemEntry);
rroot->isFree = 1;
l_in = 1;
sizeptr->size -= (int)sizeof(MemEntry);
lsiz = sizeptr;
sizeptr = rroot;
rsiz = sizeptr;
}
p = rroot;
if (size>=(500-sizeof(MemEntry))) {
printf("Entry is too big to be malloc'd ERROR\n");
printf("%p SIZE LEFT: %d\n", p, sizeptr->size);
return NULL;
}
p = (MemEntryPtr)findLoc(p, 1);
while(1){
if (p==0) {
printf("Not enough memory to fill that request\n");
printf("%p SIZE LEFT: %d\n", sizeptr, sizeptr->size);
return NULL;
}
if (p->size<size) {
p = p->prev;
}
else if(p->size < (size + sizeof(MemEntry))){
p->isFree = 0;
if (p->prev==0) {
sizeptr = 0;
if (initialized!=0) {
lsiz->size = 0;
}
rsiz = p;
printf("%p SIZE LEFT: %d\n", p, sizeptr->size);
p->a=127;
return (char*) p - (int)size;
}
printf("%p SIZE LEFT: %d\n", p, sizeptr->size);
p->a=127;
return (char*) p - (int)size;
}
else{
pre = (MemEntry*) ((char *) p - sizeof(MemEntry) - size);
pre-> succ = p;
pre-> prev = p->prev;
if(p->prev!=0){
p->prev->succ = pre;
}
pre->size = p->size - (int)sizeof(MemEntry) - size;
if (p->prev==0) {
sizeptr = pre;
if (initialized!=0) {
lsiz->size = sizeptr->size;
}
rsiz = sizeptr;
}
p-> prev = pre;
pre->isFree = 1;
p-> size = size;
p->isFree = 0;
printf("%p SIZE LEFT: %d\n", p, sizeptr->size);
p->a=127;
return (char *)p - (int)size;
}
p = (MemEntryPtr)findLoc(p, 0);
}
}
}
