map.c

Go to the documentation of this file.

#include "map.h"
#include <sys/shm.h>
#include <stdlib.h>
#include <stdio.h>
#include <sys/stat.h>
#include <math.h>

#define GETMAPPOS(i,j) (map->cells[j][i].value) 
#define GETFLAG(i,j) (map->cells[j][i].flag) 
static Map * map = NULL;
int shmap_id;
int ShmapInit(int init_flag){
        const int shmap_size = sizeof(Map);
        if (map == NULL){
                // Allocate memory to shared map
                shmap_id = shmget (SHM_MAP_KEY , shmap_size, IPC_CREAT | S_IRUSR | S_IWUSR);    // Removed  flag IPC_EXCL 
        
                if (shmap_id == -1) {
                        perror("shmget");
                        exit(1);
                }
        
                /* Attach the shared memory segment.  */
                map = (Map *) shmat (shmap_id, 0, 0);
                if ((int)map == -1) {
                        perror("shmat");
                        exit(1);
                }
        
                /* Initialize Map Memory */
                if(init_flag) ShmapAllFreeSpace();
        
                //printf("Map initialized\n");
        }
        return 1;

}

void ShmapFree(void){
        /* Deatch the shared memory segment.  */
        shmdt (map);

        /* Deallocate the shared memory segment.  */
        shmctl (shmap_id, IPC_RMID, 0);
}

void ShmapDt(void){
        /* Deatch the shared memory segment.  */
        shmdt (map);

}
int ShmapIsMapInit(void){
        if (map == NULL) return 0;
        else return 1;

}
void ShmapAllFreeSpace(void){
        int i,j;
        for (j=0;j<MAP_HEIGHT;j++){
                for(i=0;i<MAP_WIDTH;i++){
                        ShmapSetCellValue(i,j, MAP_FREE);
                        ShmapSetCellFlag(i,j, MAP_FLAG_NO_FLAG);
                }
        }
}

void ShmapClearOldPath(void){
        int i,j;
        for (j=0;j<MAP_HEIGHT;j++){
                for(i=0;i<MAP_WIDTH;i++){
                        if(ShmapIsFreeCell(i,j)) ShmapSetCellValue(i,j, MAP_FREE);
                }
        }
}


int ShmapIsCellInMap(int x, int y){
        if( ( x < MAP_WIDTH ) && (y < MAP_HEIGHT) && ( x >= 0 ) && ( y >= 0) ) return 1;
        else return 0;
}
int ShampIsPointInMap(double x_m, double y_m){
        return ShmapIsCellInMap(ShmapPoint2Cell_X(x_m), ShmapPoint2Cell_Y(y_m));
}


int ShmapSetCellValue(int x, int y, MapCellValue value){
        if(ShmapIsCellInMap(x,y)){
                GETMAPPOS(x,y)  = value;
                return 1;
        } else return 0;
        
}
int ShmapSetPointValue(double x_m, double y_m, MapCellValue value){
        return ShmapSetCellValue(ShmapPoint2Cell_X(x_m), ShmapPoint2Cell_Y(y_m), value);
}

void ShmapUpdateTmpObstacles(MapCellValue val){
        int i,j;
        MapCellValue act;
        if (ShmapIsMapInit()){
                for (j=0;j<MAP_HEIGHT;j++){
                        for(i=0;i<MAP_WIDTH;i++){
                                act = ShmapGetCellValue(i,j);
                                if ( (act != (MapCellValue) MAP_NOT_IN_MAP) && (act <= (MapCellValue) MAP_NEW_OBSTACLE) && (act >  (MapCellValue) MAP_FREE)){
                                        if (val<act) {
                                                act = act - val;
                                                ShmapSetCellValue(i,j, act);
                                        } else ShmapSetCellValue(i,j, MAP_FREE);
                                }
                        }
                }
        }
}

MapCellValue ShmapGetCellValue(int x, int y){
        if (ShmapIsMapInit() && ShmapIsCellInMap(x,y)) return GETMAPPOS(x,y);
        else return MAP_NOT_IN_MAP;
        
}

MapCellValue ShmapGetPointValue(double x_m, double y_m){
        return ShmapGetCellValue(ShmapPoint2Cell_X(x_m), ShmapPoint2Cell_Y(y_m));
}

int ShmapIsFreeCell(int x, int y){
        if(ShmapIsCellInMap(x,y)) {
                switch (ShmapGetCellValue(x,y)){
                        case MAP_START:
                        case MAP_GOAL:
                        case MAP_PATH:
                        case MAP_FREE:
                                return 1;
                                break;
                        default:
                                return 0;
                                break;
                }
        } else return -1;
}
int ShmapIsFreePoint(double x_m, double y_m){
        return ShmapIsFreeCell(ShmapPoint2Cell_X(x_m), ShmapPoint2Cell_Y(y_m));
}

int ShmapSetRectangleType(double x1, double y1, double x2, double y2, MapCellValue cell){
        int i,j, init_i, limit_i, init_j, limit_j;
        if (x1 < x2){
                init_i=ShmapPoint2Cell_X(x1); limit_i = ShmapPoint2Cell_X(x2);
        } else {
                init_i=ShmapPoint2Cell_X(x2); limit_i = ShmapPoint2Cell_X(x1);
        }
        if (y1 > y2){
                init_j=ShmapPoint2Cell_Y(y1); limit_j = ShmapPoint2Cell_Y(y2);
        } else {
                init_j=ShmapPoint2Cell_Y(y2); limit_j = ShmapPoint2Cell_Y(y1);
        }
        
        
        //DBG("Drawing a rectangle between points (%d, %d) and (%d,%d)\n", init_i,init_j,limit_i,limit_j);
        for(i=init_i;i<=limit_i;i++){
                for(j=init_j;j<=limit_j;j++){
                        //DBG("Wall in (%d,%d)\n", i,j);
                        ShmapSetCellValue(i,j,cell);
                }
        }
        return 1;
}

int ShmapPoint2Cell_X(double x){
        if ( (x>=0.0) && (x<=(MAP_PLAYGROUND_WIDTH_MM/1000.0))) {
                if (x<0.1) return 0;
                else return (( int ) ( floor( x*10 ) -1 ));
        }
        else return -1;
}

int ShmapPoint2Cell_Y(double y){
        if ( (y>=0.0) && (y<=(MAP_PLAYGROUND_HEIGHT_MM/1000.0))){
                if (y<0.1) return (MAP_HEIGHT-1);
                else return (( int ) (MAP_HEIGHT-floor( y*10 ) ));
        }
        else return -1;
}

double ShmapCell2Point_X(int x){
        if ( (x>=0) && (x<=(MAP_WIDTH-1))) return ((x+0.5)/10.0);
        else return -1;

}

double ShmapCell2Point_Y(int y){
        if ( (y>=0) && (y<=(MAP_HEIGHT-1))) return (((MAP_HEIGHT-y)-0.5)/10.0);
        else return -1;
}

int ShmapSetCellFlag(int x, int y, MapCellFlag flag){
        if(ShmapIsCellInMap(x,y)){
                GETFLAG(x,y)  = flag;
                return 1;
        } else return 0;
}

int ShmapSetPointFlag(double x_m, double y_m, MapCellFlag flag){
        return ShmapSetCellFlag(ShmapPoint2Cell_X(x_m), ShmapPoint2Cell_Y(y_m), flag);
}

MapCellFlag ShmapGetCellFlag(int x, int y){
        if(ShmapIsCellInMap(x,y)) return GETFLAG(x,y);
        else return  MAP_FLAG_ERROR;
}
MapCellFlag ShmapGetPointFlag(double x_m, double y_m){
        return ShmapGetCellFlag(ShmapPoint2Cell_X(x_m), ShmapPoint2Cell_Y(y_m));
}

---