jps 1.0.0

data/ext/jps/map_jps.cpp

@@ -0,0 +1,230 @@
+#include "jps.hh"
+#include <iostream>
+#include <algorithm>
+#include <string>
+#include <string.h>
+#include <assert.h>
+#include <vector>
+#include "map_jps.h"
+
+using namespace std;
+
+Map *map = NULL;
+vector<JPS::Position> *path = NULL;
+// std::vector<std::string> out;
+
+inline unsigned Map::operator()(unsigned x, unsigned y) const
+{
+  unsigned canwalk = x < this->w && y < this->h;
+  if(canwalk)
+    canwalk = data[y][x] != 1;
+
+  return canwalk;
+}
+
+void Map::clear()
+{
+  int i;
+  for(i = 0;i < this->h; ++i)
+  {
+    delete[] this->data[i];
+  }
+  delete[] this->data;
+}
+
+void Map::init(int width, int height)
+{
+  this->w = width;
+  this->h = height;
+  this->data = new int*[height];
+  int i,j;
+  for(j = 0; j < height; ++j)
+  {
+    this->data[j] = new int[width];
+    for(i = 0; i < width; ++i)
+    {
+      this->data[j][i] = 0;
+    }
+  }  
+}
+
+void clearMap()
+{
+  if(!map){
+    delete map;
+    map = NULL;
+  }
+}
+
+void clearPath()
+{
+  if(!path)
+  {
+    delete path;
+    path = NULL;
+  }
+}
+
+vector<JPS::Position> * findPath(int startX, int startY, int stopX, int stopY)
+{
+  if(!map || !path){
+    return NULL;
+  }
+
+  path->clear();
+
+  //开始和结束位置不能是障碍 不然找不到路径
+  //这里先设置成非障碍，查询结束后重置回去
+  int oldStartFlag = map->data[startY][startX];
+  int oldStopFlag = map->data[stopY][stopX];
+  map->data[startY][startX] = 0;
+  map->data[stopY][stopX] = 0;
+
+  JPS::PathVector waypoints;
+  JPS::PathVector result;
+  waypoints.push_back(JPS::Pos(JPS::PosType(startX), startY));
+  waypoints.push_back(JPS::Pos(JPS::PosType(stopX), stopY));
+
+  JPS::Searcher<Map> search(*map);
+  search.findPath(result, waypoints[0], waypoints[1], 1);
+
+  int curX = startX;
+  int curY = startY;
+  for(JPS::PathVector::iterator it = result.begin(); it != result.end(); ++it)
+  {
+    int x = it -> x;
+    int y = it -> y;
+
+    //不反回目标点
+    // if(x == stopX && y == stopY)
+    // {
+    //   break;
+    // }
+
+    if(curX != x && curY != y)
+    {
+      JPS::Position pos1;
+      if(map->data[curY][x] == 0)
+      {
+        pos1.x = x;
+        pos1.y = curY;
+        path->push_back(pos1);
+        curX = x;
+      }
+      else if(map->data[y][curX] == 0)
+      {
+        pos1.x = curX;
+        pos1.y = y;
+        path->push_back(pos1);
+        curY = y;
+      }
+    }
+
+    JPS::Position pos2;
+    pos2.x = x;
+    pos2.y = y;
+    path->push_back(pos2);
+    curX = x;
+    curY = y; 
+  }
+
+  //查询结束后重置回去
+  map->data[startY][startX] = oldStartFlag;
+  map->data[stopY][stopX] = oldStopFlag;
+  return path;
+}
+
+JPS::Position findDstPos(int startX,int startY, int endX, int endY,int step)
+{
+  JPS::Position dstPos;
+  if(!map){
+    return dstPos;
+  }
+
+  int oldStartFlag = map->data[startY][startX];
+  int oldStopFlag = map->data[endY][endX];
+  map->data[startY][startX] = 0;
+  map->data[endY][endX] = 0;
+
+  JPS::PathVector waypoints;
+  
+  waypoints.push_back(JPS::Pos(startX, startY));
+  waypoints.push_back(JPS::Pos(endX, endY));
+  
+  JPS::PathVector result;
+  JPS::Searcher<Map> search(*map);
+  search.findPath(result, waypoints[0], waypoints[1], 1);
+
+  int curStep = 0;
+  int curX = startX;
+  int curY = startY;
+  for(JPS::PathVector::iterator it = result.begin(); it != result.end(); ++it)
+	{
+    int y = it->y;
+    int x = it->x;
+    //到最后一个点的话使用倒数第二个点
+    if(x == endX && y == endY)
+    {
+      dstPos.x = curX;
+      dstPos.y = curY;
+      break;
+    }
+
+    if(curX != x && curY != y)
+    {
+      vector<int> v1;
+      if(map->data[curY][x] == 0)
+        curX = x;
+      else if(map->data[y][curX] == 0)
+        curY = y;
+      curStep++;
+
+      if(curStep == step)
+      {
+        dstPos.x = curX;
+        dstPos.y = curY;
+        break;
+      }
+    }
+  
+    curX = x;
+    curY = y;
+    curStep++;
+
+    if(curStep == step )
+    {
+      dstPos.x = curX;
+      dstPos.y = curY;
+      break;
+    }
+	}
+
+  map->data[startY][startX] = oldStartFlag;
+  map->data[endY][endX] = oldStopFlag;
+
+  return dstPos;
+  
+}
+
+void initMap(int width,int height)
+{
+  if(map != NULL){
+    clearMap();
+  }
+  if(path != NULL){
+    clearPath();
+  }
+
+  map = new Map();
+  map->init(width, height);
+
+  path = new vector<JPS::Position>();
+}
+
+void setMapPos(int posX, int posY,int flag)
+{
+  if(!map){
+    return;
+  }
+  map->data[posY][posX] = flag;
+}

data/ext/jps/map_jps.h

@@ -0,0 +1,22 @@
+#ifndef MAP_JPS_H_
+#define MAP_JPS_H_
+#include "jps.hh"
+#include <vector>
+#include <iostream>
+using namespace std;
+  struct Map{
+    void init(int width, int height);
+    void clear();
+    unsigned operator()(unsigned x, unsigned y) const;
+    int w,h;
+    int **data;
+  };
+
+  void clearMap();
+  void clearPath();
+  void initMap(int width,int height);
+  vector<JPS::Position> * findPath(int startX, int startY, int stopX, int stopY);
+  JPS::Position findDstPos(int startX,int startY, int endX, int endY,int step);
+  void initMap(int width,int height);
+  void setMapPos(int posX, int posY,int flag);
+#endif

data/ext/jps/rjps.cpp

@@ -0,0 +1,126 @@
+#include <ruby.h>
+
+#include "map_jps.h"
+#include "jps.hh"
+#include <vector>
+
+extern vector<JPS::Position> *path;
+extern Map *map;
+
+
+VALUE find_path(VALUE self, VALUE start_x, VALUE start_y, VALUE stop_x, VALUE stop_y)
+{
+  if(map == NULL)
+    return rb_str_new2("Map is null, plz init map first!");
+  if(path == NULL)
+    return rb_str_new2("path is null, plz init map first!");
+
+  int startX = NUM2INT(start_x);
+  int startY = NUM2INT(start_y);
+  int stopX = NUM2INT(stop_x);
+  int stopY = NUM2INT(stop_y);
+  
+  vector<JPS::Position> * p;
+  p = findPath(startX, startY, stopX, stopY);
+  
+  VALUE arr1 = rb_ary_new();
+  int i;
+  for(i=0; i< p->size(); ++i)
+  {  
+    VALUE arr2 = rb_ary_new();
+    JPS::Position ret = (*path)[i];
+    rb_ary_push(arr2, INT2NUM(ret.x));
+    rb_ary_push(arr2, INT2NUM(ret.y));
+    rb_ary_push(arr1, arr2); 
+  }
+  
+  return arr1;
+  // return INT2FIX(p);
+}
+
+VALUE get_path_length(VALUE self)
+{
+  return INT2NUM(path->size());
+}
+
+VALUE clear_map(VALUE self)
+{
+  clearMap();
+  clearPath();
+  return INT2NUM(0);
+}
+
+VALUE find_dst_pos(VALUE self, VALUE start_x, VALUE start_y, VALUE end_x, VALUE end_y, VALUE step)
+{
+  if(map == NULL)
+    return rb_str_new2("Map is null, plz init map first!");
+  if(path == NULL)
+    return rb_str_new2("path is null, plz init map first!");
+
+  int startX = NUM2INT(start_x);
+  int startY = NUM2INT(start_y);
+  int endX = NUM2INT(end_x);
+  int endY = NUM2INT(end_y);
+  int sp = NUM2INT(step);
+  
+  if(startX < 0 || startX >= map->w)
+    return rb_str_new2("startX is overflow!");
+  if(startY < 0 || startY >= map->w)
+    return rb_str_new2("startY is overflow!");
+  if(endX < 0 || endX >= map->w)
+    return rb_str_new2("endX is overflow!");
+  if(endY < 0 || endY >= map->w)
+    return rb_str_new2("endY is overflow!");
+
+  JPS::Position ret = findDstPos(startX, startY, endX, endY, sp);
+
+  VALUE point = rb_ary_new();
+  rb_ary_push(point, INT2NUM(ret.x));
+  rb_ary_push(point, INT2NUM(ret.y));
+  return point;
+
+}
+
+VALUE get_path_point(VALUE self, VALUE idx)
+{
+  int index = NUM2INT(idx);
+  JPS::Position ret = (*path)[index];
+  VALUE point = rb_ary_new();
+  rb_ary_push(point, INT2NUM(ret.x));
+  rb_ary_push(point, INT2NUM(ret.y));
+  return point;
+}
+
+VALUE set_map_pos(VALUE self, VALUE posX, VALUE posY, VALUE flag)
+{
+  if(map == NULL)
+    return rb_str_new2("Map is null, plz init map first!");
+  int x = NUM2INT(posX);
+  int y = NUM2INT(posY);
+  int fg = NUM2INT(flag);
+
+  setMapPos(x, y, fg);
+  return INT2NUM(0);
+}
+
+VALUE init_map(VALUE self, VALUE width, VALUE height)
+{
+  int w = NUM2INT(width);
+  int h = NUM2INT(height);
+  initMap(w, h);
+  return INT2NUM(0);
+}
+
+
+extern "C" void Init_rjps()
+{
+  VALUE jps = rb_define_module("Jps");
+  rb_define_module_function(jps, "find_path", RUBY_METHOD_FUNC(find_path), 4);
+  rb_define_module_function(jps, "init_map", RUBY_METHOD_FUNC(init_map), 2);
+  rb_define_module_function(jps, "get_path_length", RUBY_METHOD_FUNC(get_path_length), 0);
+  rb_define_module_function(jps, "get_path_point", RUBY_METHOD_FUNC(get_path_point), 1);
+  rb_define_module_function(jps, "set_map_pos", RUBY_METHOD_FUNC(set_map_pos), 3);
+  rb_define_module_function(jps, "clear_map", RUBY_METHOD_FUNC(clear_map), 0);
+  rb_define_module_function(jps, "find_dst_pos", RUBY_METHOD_FUNC(find_dst_pos), 5);
+}
+

metadata

@@ -0,0 +1,49 @@
+--- !ruby/object:Gem::Specification
+name: jps
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- ljf
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-09-18 00:00:00.000000000 Z
+dependencies: []
+description: jps automated test application
+email: xxxxxxx@xxxnets.com
+executables: []
+extensions:
+- ext/jps/extconf.rb
+extra_rdoc_files: []
+files:
+- ext/jps/extconf.rb
+- ext/jps/jps.hh
+- ext/jps/map_jps.cpp
+- ext/jps/map_jps.h
+- ext/jps/rjps.cpp
+homepage: http://172.17.2.44:9527/welcome/index
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.6.14
+signing_key: 
+specification_version: 4
+summary: jps
+test_files: []