精华内容
下载资源
问答
  • 加密参数如图: desc: coBPtm4BZy5Ly7E1arnlj2vpMZNyrN...getParams方法是加密入口方法,深入下去,发现是DES加密算法。 部分加密算法代码: function getParams() { var e = { xy: mcArrs, fingerprint: (new re

    加密参数如图:
    在这里插入图片描述
    desc: coBPtm4BZy5Ly7E1arnlj2vpMZNyrN/1%2BLDoZV95IdUg4tn6MrBJX4I6VhmHGTkY
    该值就是加密后的参数,经过分析发现该参数实际调用的getParams方法进行生成。
    getParams方法是加密的入口方法,深入下去,发现是DES加密算法。

    部分加密算法代码:

    function getParams() {
        var e = {
            xy: mcArrs,
            fingerprint: (new referFingerprint).get()
        };
        mcArrs = [];
        var t = JSON.stringify(e);
        var r = eq_u(t, m);
        return del_html_tags(r, "\\+", "%2B")
    }
    
    function eq_u(e, t) {
        var r = coypJsDk.enc.Utf8.parse(t);
        var i = coypJsDk.DES.encrypt(e, r, {
            mode: coypJsDk.mode.CBC,
            padding: coypJsDk.pad.Nopk
        });
        return i.toString()
    }
    
    function del_html_tags(e, t, r) {
        var i = new RegExp(t,"g");
        words = e.replace(i, r);
        return words
    }
    
    born.prototype = {
        getCiphertext: function() {
            return getParams()
        }
    };
    

    以上都是废话~~下面才是核心,dx算法过于复杂,不做阐述,直接上结果。

    完整算法(该算法是翻译过后的,可直接调用,兼容IEJS和V8JS引擎运行):

    链接: https://pan.baidu.com/s/1hF1xb8asBfgpixN0VrRBow 提取码: xy58

    使用说明:

    jd_desc.js

    用于生成desc参数,调用jd_desc.js的GetDesc(ua)方法返回desc和fingerPrint两个参数。

    jd_dx.js

    dx风控算法,指请求c1时headers中的Param参数算法,具体用法:
    首次请求c1时(两种情况):

    1. 网站cookies中有_dx_uzZo5y参数时调用jd_dx.js中的init1(cookies)方法,返回结果用于Param参数。
    2. 网站cookies中没有_dx_uzZo5y参数时调用jd_dx.js中的init1s(cookies)方法,返回结果用于Param参数。

    二次请求c1时(两步):

    1. 将首次请求的返回结果中的data参数保留下来。
    2. 调用jd_dx.js中的init2(data, ua)方法,返回结果用于Param参数。
      PS:该算法仅限该网站可用,其他网站没测试,其他网站可能dx版本不一样,略有差异。
    展开全文
  • dx图像增强算法

    2019-09-25 11:40:40
    基于多尺度对比度x射线图像...该算法是经过多年实践完善dx增强算法 算法2是在算法1基础上完善, 主要解决了边阴影问题; 黑背景问题;增强过度边界溢出问题; 同时还解决了因为去栅后处理增强栅线问题; 程序使...

        

    基于多尺度对比度x射线图像增强算法2

    基本流程  :

    LOG校正--->>图像分解-->>图像细节处理-->>图像重建-->>输出曲线调整.

    该算法是经过多年实践完善dx增强算法 算法2是在算法1的基础上完善的, 主要解决了边阴影问题; 黑背景问题;增强过度边界溢出问题; 同时还解决了因为去栅后处理增强栅线问题; 程序使用SSE指令集和intel编译器 使得增加处理过程后不增加处理时间; 该算法对线对几乎没有影响,最大限度保持了线对; 该程序只是处理DEMO版本,只有一个默认参数,

    demo下载地址

    http://download.csdn.net/detail/moyumoyu/9587475

    效果图像:

    转载于:https://www.cnblogs.com/moyumoyu/articles/5777286.html

    展开全文
  • Absentia DX算法分析生产对话记录,然后删除明显嗡嗡声,无线铃声和滴答声,同时保持人声完整性。 ABDX是为网络电视节目开发,具有难以产生声音,导致大量重复体力劳动。 只需将卷,文件夹或声音文件直接...
  • dx图像增强算法2

    热门讨论 2016-07-27 13:14:56
    该增强工具是第二版,较第一版有很大改进,内含测试x射线原始图,瓦里安探测器原始图,康众探测器原始图,东芝探测器原始图,品臻探测器原始图。以及线对卡测试图像。
  • cocos2dx A*算法

    2014-11-27 12:00:43
    头文件和源文件复制到项目中就能用了! have fun 使用cocos2dx 3.2 原理都一样 淡蓝色点是地图 ...深蓝色点是障碍物 ...绿色点是路径 ...暗绿色点是搜寻过点 ...最佳优先搜索算法会发现寻找过

    头文件和源文件复制到项目中就能用了! have fun

    使用cocos2dx 3.2 原理都一样

    淡蓝色的点是地图

    深蓝色的点是障碍物

    绿色的点是路径

    暗绿色的点是搜寻过的点

    红色的点是按路径行走的点



    dijkstra算法 会发现路径最短,但寻找过的路径比较多(计算速度慢)



    最佳优先搜索算法会发现寻找过的路径少了(计算速度提高了),但走了许多弯路



    A星算法 结合了上面2种算法 即寻找到了最短路径, 搜寻过的路径也比较少



    1. #ifndef __HELLOWORLD_SCENE_H__  
    2. #define __HELLOWORLD_SCENE_H__  
    3.   
    4. #include "cocos2d.h"  
    5. #include "vector"  
    6. using namespace std;  
    7. USING_NS_CC;  
    8.   
    9.   
    10. class PathSprite : public cocos2d::Sprite//继承Sprite类, 因为要在里面加些其他变量  
    11. {  
    12.     PathSprite():Sprite()  
    13.     {  
    14.         m_parent = NULL;  
    15.         m_child = NULL;  
    16.         m_costToSource = 0;  
    17.         m_FValue = 0;  
    18.     };  
    19. public:  
    20.     static PathSprite* create(const char* ch)  
    21.     {  
    22.         PathSprite *pRet = new PathSprite();  
    23.         if (pRet )  
    24.         {  
    25.             pRet->initWithFile(ch);  
    26.             pRet->autorelease();  
    27.             return pRet;  
    28.         }  
    29.         else  
    30.         {  
    31.             delete pRet;  
    32.             pRet = NULL;  
    33.             return NULL;  
    34.         }  
    35.     }  
    36.     PathSprite* m_parent;//父节点  
    37.     PathSprite* m_child;//子节点  
    38.     float m_costToSource;//到起始点的距离  
    39.     int m_x;//地图坐标  
    40.     int m_y;  
    41.     float m_FValue;  
    42. };  
    43.   
    44. class PathSearchInfo//寻路类(主要负责寻路的参数和逻辑)  
    45. {  
    46. public:  
    47.       
    48.     static int m_startX;//开始点  
    49.     static int m_startY;  
    50.     static int m_endX;//结束点  
    51.     static int m_endY;  
    52.       
    53.     static vector<PathSprite*> m_openList;//开放列表(里面存放相邻节点)  
    54.     static vector<PathSprite*> m_inspectList;//检测列表(里面存放除了障碍物的节点)  
    55.     static vector<PathSprite*> m_pathList;//路径列表  
    56.     static void  barrierTest( vector<PathSprite*> &pathList,int x, int y)//模拟障碍物  
    57.     {  
    58.         PathSprite* _z = getObjByPointOfMapCoord(pathList, x, y);  
    59.         if (_z)  
    60.         {  
    61.             _z->setColor(ccColor3B::MAGENTA);  
    62.             removeObjFromList(pathList, _z);  
    63.         }  
    64.     }  
    65.     static float calculateTwoObjDistance(PathSprite* obj1, PathSprite* obj2)//计算两个物体间的距离  
    66.     {  
    67. //        float _offsetX = obj1->m_x - obj2->m_x;  
    68. //        float _offsetY = obj1->m_y - obj2->m_y;  
    69. //        return sqrt( _offsetX * _offsetX + _offsetY * _offsetY);  
    70.           
    71.         float _x = abs(obj2->m_x - obj1->m_x);  
    72.         float _y = abs(obj2->m_y - obj1->m_y);  
    73.           
    74.         return _x + _y;  
    75.     }  
    76.     static void inspectTheAdjacentNodes(PathSprite* node, PathSprite* adjacent, PathSprite* endNode)//把相邻的节点放入开放节点中  
    77.     {  
    78.         if (adjacent)  
    79.         {  
    80.             float _x = abs(endNode->m_x - adjacent->m_x);  
    81.             float _y = abs(endNode->m_y - adjacent->m_y);  
    82.               
    83.             float F , G, H1, H2, H3;  
    84.             adjacent->m_costToSource = node->m_costToSource + calculateTwoObjDistance(node, adjacent);//获得累计的路程  
    85.             G = adjacent->m_costToSource;  
    86.               
    87.             //三种算法, 感觉H2不错  
    88.             H1 = _x + _y;  
    89.             H2 = hypot(_x, _y);  
    90.             H3 = max(_x, _y);  
    91.   
    92. #if 1 //A*算法 = Dijkstra算法 + 最佳优先搜索  
    93.             F = G + H2;  
    94. #endif  
    95. #if 0//Dijkstra算法  
    96.             F = G;  
    97. #endif  
    98. #if 0//最佳优先搜索  
    99.             F = H2;  
    100. #endif  
    101.             adjacent->m_FValue = F;  
    102.               
    103.             adjacent->m_parent = node;//设置父节点  
    104.             adjacent->setColor(Color3B::ORANGE);//搜寻过的节点设为橘色  
    105.             node->m_child = adjacent;//设置子节点  
    106.             PathSearchInfo::removeObjFromList(PathSearchInfo::m_inspectList, adjacent);//把检测过的点从检测列表中删除  
    107.             PathSearchInfo::m_openList.push_back(adjacent);//加入开放列表  
    108.         }  
    109.     }  
    110.     static PathSprite* getMinPathFormOpenList()//从开放节点中获取路径最小值  
    111.     {  
    112.         if (m_openList.size()>0) {  
    113.             PathSprite* _sp =* m_openList.begin();  
    114.             for (vector<PathSprite*>::iterator iter = m_openList.begin(); iter !=  m_openList.end(); iter++)  
    115.             {  
    116.                 if ((*iter)->m_FValue < _sp->m_FValue)  
    117.                 {  
    118.                     _sp = *iter;  
    119.                 }  
    120.             }  
    121.             return _sp;  
    122.         }  
    123.         else  
    124.         {  
    125.             return NULL;  
    126.         }  
    127.           
    128.     }  
    129.     static PathSprite* getObjByPointOfMapCoord( vector<PathSprite*> &spriteVector,  int x, int y)//根据点获取对象  
    130.     {  
    131.         for (int i = 0; i < spriteVector.size(); i++)  
    132.         {  
    133.             if (spriteVector[i]->m_x == x && spriteVector[i]->m_y == y)  
    134.             {  
    135.                 return spriteVector[i];  
    136.             }  
    137.         }  
    138.         return NULL;  
    139.     }  
    140.     static bool removeObjFromList(vector<PathSprite*> &spriteVector, PathSprite* sprite)//从容器中移除对象  
    141.     {  
    142.         for (vector<PathSprite*>::iterator iter = spriteVector.begin(); iter !=  spriteVector.end(); iter++)  
    143.         {  
    144.             if (*iter == sprite)  
    145.             {  
    146.                 spriteVector.erase(iter);  
    147.                 return true;  
    148.             }  
    149.         }  
    150.         return false;  
    151.           
    152.     }  
    153. };  
    154.   
    155. class HelloWorld : public cocos2d::Layer  
    156. {  
    157. public:  
    158.     // there's no 'id' in cpp, so we recommend returning the class instance pointer  
    159.     static cocos2d::Scene* createScene();  
    160.       
    161.     // Here's a difference. Method 'init' in cocos2d-x returns bool, instead of returning 'id' in cocos2d-iphone  
    162.     virtual bool init();    
    163.       
    164.     // a selector callback  
    165.     void menuCloseCallback(cocos2d::Ref* pSender);  
    166.       
    167.     // implement the "static create()" method manually  
    168.     CREATE_FUNC(HelloWorld);  
    169.       
    170.     bool onTouchBegan(Touch* touch, Event* event);  
    171.     void onTouchMoved(Touch* touch, Event* event);  
    172.     void onTouchEnded(Touch* touch, Event* event);  
    173.       
    174.     void calculatePath();//计算路径  
    175.     void drawPath();//绘制路径  
    176.     vector<PathSprite*> m_mapList;//地图  
    177.       
    178.     void clearPath();//清理路径  
    179.       
    180.     PathSprite* m_player;//人物 用于演示行走  
    181.     int m_playerMoveStep;//人物当前的行程  
    182.     void playerMove();//人物走动  
    183. };  
    184.   
    185. #endif // __HELLOWORLD_SCENE_H__  
    1. #include "HelloWorldScene.h"  
    2.   
    3. vector<PathSprite*> PathSearchInfo::m_openList;  
    4.   
    5. vector<PathSprite*> PathSearchInfo::m_inspectList;  
    6.   
    7. vector<PathSprite*> PathSearchInfo::m_pathList;  
    8.   
    9. int PathSearchInfo::m_startX;  
    10.   
    11. int PathSearchInfo::m_startY;  
    12.   
    13. int PathSearchInfo::m_endX;  
    14.   
    15. int PathSearchInfo::m_endY;  
    16.   
    17. Scene* HelloWorld::createScene()  
    18. {  
    19.     // 'scene' is an autorelease object  
    20.     auto scene = Scene::create();  
    21.       
    22.     // 'layer' is an autorelease object  
    23.     auto layer = HelloWorld::create();  
    24.       
    25.     // add layer as a child to scene  
    26.     scene->addChild(layer);  
    27.       
    28.     // return the scene  
    29.     return scene;  
    30. }  
    31.   
    32. // on "init" you need to initialize your instance  
    33. bool HelloWorld::init()  
    34. {  
    35.     //  
    36.     // 1. super init first  
    37.     if ( !Layer::init() )  
    38.     {  
    39.         return false;  
    40.     }  
    41.       
    42.     Size visibleSize = Director::getInstance()->getVisibleSize();  
    43.     Vec2 origin = Director::getInstance()->getVisibleOrigin();  
    44.     Size winSize = Director::getInstance()->getWinSize();  
    45.       
    46.     /  
    47.     // 2. add a menu item with "X" image, which is clicked to quit the program  
    48.     //    you may modify it.  
    49.       
    50.     // add a "close" icon to exit the progress. it's an autorelease object  
    51.       
    52.     auto listener = EventListenerTouchOneByOne::create();  
    53.     listener->setSwallowTouches(true);  
    54.       
    55.     listener->onTouchBegan = CC_CALLBACK_2(HelloWorld::onTouchBegan, this);  
    56.     listener->onTouchMoved = CC_CALLBACK_2(HelloWorld::onTouchMoved, this);  
    57.     listener->onTouchEnded = CC_CALLBACK_2(HelloWorld::onTouchEnded, this);  
    58.       
    59.     _eventDispatcher->addEventListenerWithSceneGraphPriority(listener, this);  
    60.       
    61.       
    62.       
    63.     //模拟一张地图 左上角 为(0,0) 主要是模拟tiledmap  每块的宽度为1  
    64.     int _width = 25;  
    65.     int _heigth = 15;  
    66.     for (int i = 0; i < _heigth; i++)  
    67.     {  
    68.         for (int j = 0; j < _width; j++)  
    69.         {  
    70.             PathSprite* _sp = PathSprite::create("CloseNormal.png");  
    71.             _sp->m_x = j;  
    72.             _sp->m_y = i;  
    73.             Size _size = _sp->getContentSize();  
    74.             _sp->setPosition(CCPoint(j * _size.width + 100, - i * _size.height + 600));  
    75.             m_mapList.push_back(_sp);  
    76.             this->addChild(_sp);  
    77.         }  
    78.     }  
    79.       
    80.     //设置障碍物  
    81. //    for (int i = 0; i < _heigth*_width/2; i++)  
    82. //    {  
    83. //          
    84. //        int _x = CCRANDOM_0_1()*_width;  
    85. //        int _y = CCRANDOM_0_1()*_heigth;  
    86. //        if (_x ==0 && _y == 0) {  
    87. //            continue;  
    88. //        }  
    89. //        PathSearchInfo::barrierTest(m_mapList,_x,_y);  
    90. //    }  
    91.     for (int i = 0; i < 10; i++) {  
    92.         PathSearchInfo::barrierTest(m_mapList,5+i,10);  
    93.         PathSearchInfo::barrierTest(m_mapList,15,i+1);  
    94.     }  
    95.       
    96.         //PathSprite::getObjByPointOfMapCoord(m_inspectList, 2, 5)->removeFromParent();  
    97.       
    98.     //设置起始和终点  
    99.     PathSearchInfo::m_startX =0;  
    100.     PathSearchInfo::m_startY = 0;  
    101.       
    102.     PathSearchInfo::m_endX = 4;  
    103.     PathSearchInfo::m_endY = 9;  
    104.       
    105.     m_player = PathSprite::create("CloseSelected1.png");  
    106.     m_player->setColor(Color3B::RED);  
    107.     this->addChild(m_player);  
    108.       
    109.     m_player->m_x = PathSearchInfo::m_startX;  
    110.     m_player->m_y = PathSearchInfo::m_startY;  
    111.     m_player->setPosition(PathSearchInfo::getObjByPointOfMapCoord(m_mapList, PathSearchInfo::m_startX, PathSearchInfo::m_startY)->getPosition());  
    112.     return true;  
    113. }  
    114.   
    115. void HelloWorld::calculatePath()  
    116. {  
    117.       
    118.     //得到开始点的节点  
    119.     PathSprite* _sp = PathSearchInfo::getObjByPointOfMapCoord(PathSearchInfo::m_inspectList, PathSearchInfo::m_startX, PathSearchInfo::m_startY);  
    120.     //得到开始点的节点  
    121.     PathSprite* _endNode = PathSearchInfo::getObjByPointOfMapCoord(PathSearchInfo::m_inspectList, PathSearchInfo::m_endX, PathSearchInfo::m_endY);  
    122.     //因为是开始点 把到起始点的距离设为0  
    123.     _sp->m_costToSource = 0;  
    124.     _sp->m_FValue = 0;  
    125.     //把已经检测过的点从检测列表中删除  
    126.     PathSearchInfo::removeObjFromList(PathSearchInfo::m_inspectList, _sp);  
    127.     //然后加入开放列表  
    128.     PathSearchInfo::m_openList.push_back(_sp);  
    129.       
    130.     PathSprite* _node = NULL;  
    131.     while (true)  
    132.     {  
    133.         //得到离起始点最近的点  
    134.         _node = PathSearchInfo::getMinPathFormOpenList();  
    135.         if (!_node)  
    136.         {  
    137.             //找不到路径  
    138.             break;  
    139.         }  
    140.         //把计算过的点从开放列表中删除  
    141.         PathSearchInfo::removeObjFromList(PathSearchInfo::m_openList, _node);  
    142.         int _x = _node->m_x;  
    143.         int _y = _node->m_y;  
    144.           
    145.         //  
    146.         if (_x ==PathSearchInfo::m_endX && _y == PathSearchInfo::m_endY)  
    147.         {  
    148.             break;  
    149.         }  
    150.           
    151.         //检测8个方向的相邻节点是否可以放入开放列表中  
    152.         PathSprite* _adjacent = PathSearchInfo::getObjByPointOfMapCoord(PathSearchInfo::m_inspectList, _x + 1, _y + 1);  
    153.         PathSearchInfo::inspectTheAdjacentNodes(_node, _adjacent, _endNode);  
    154.           
    155.         _adjacent = PathSearchInfo::getObjByPointOfMapCoord(PathSearchInfo::m_inspectList, _x +1, _y);  
    156.         PathSearchInfo::inspectTheAdjacentNodes(_node, _adjacent, _endNode);  
    157.           
    158.         _adjacent = PathSearchInfo::getObjByPointOfMapCoord(PathSearchInfo::m_inspectList, _x +1, _y-1);  
    159.         PathSearchInfo::inspectTheAdjacentNodes(_node, _adjacent, _endNode);  
    160.           
    161.         _adjacent = PathSearchInfo::getObjByPointOfMapCoord(PathSearchInfo::m_inspectList, _x , _y -1);  
    162.         PathSearchInfo::inspectTheAdjacentNodes(_node, _adjacent, _endNode);  
    163.           
    164.         _adjacent = PathSearchInfo::getObjByPointOfMapCoord(PathSearchInfo::m_inspectList, _x -1, _y - 1);  
    165.         PathSearchInfo::inspectTheAdjacentNodes(_node, _adjacent, _endNode);  
    166.           
    167.         _adjacent = PathSearchInfo::getObjByPointOfMapCoord(PathSearchInfo::m_inspectList, _x -1, _y);  
    168.         PathSearchInfo::inspectTheAdjacentNodes(_node, _adjacent, _endNode);  
    169.           
    170.         _adjacent = PathSearchInfo::getObjByPointOfMapCoord(PathSearchInfo::m_inspectList, _x -1, _y+1);  
    171.         PathSearchInfo::inspectTheAdjacentNodes(_node, _adjacent, _endNode);  
    172.           
    173.         _adjacent = PathSearchInfo::getObjByPointOfMapCoord(PathSearchInfo::m_inspectList, _x , _y+1);  
    174.         PathSearchInfo::inspectTheAdjacentNodes(_node, _adjacent, _endNode);  
    175.           
    176.     }  
    177.       
    178.     while (_node)  
    179.     {  
    180.         //PathSprite* _sp = node;  
    181.         PathSearchInfo::m_pathList.insert(PathSearchInfo::m_pathList.begin(), _node);  
    182.         _node = _node->m_parent;  
    183.     }  
    184. }  
    185.   
    186.   
    187. void HelloWorld::drawPath(  )  
    188. {  
    189.     for (vector<PathSprite*>::iterator iter = PathSearchInfo::m_pathList.begin(); iter !=  PathSearchInfo::m_pathList.end(); iter++)  
    190.     {  
    191.         (*iter)->setColor(ccColor3B::GREEN);  
    192.     }  
    193.       
    194. }  
    195.   
    196.   
    197. bool HelloWorld::onTouchBegan(Touch* touch, Event* event)  
    198. {  
    199.     //清除之前的路径  
    200.     clearPath();  
    201.       
    202.     auto nodePosition = convertToNodeSpace( touch->getLocation() );  
    203.     log("%f, %f", nodePosition.x, nodePosition.y);  
    204.     for (int i = 0; i < PathSearchInfo::m_inspectList.size(); i++)  
    205.     {  
    206.         PathSprite* _sp = PathSearchInfo::m_inspectList[i];  
    207.           
    208.         if (_sp->getBoundingBox().containsPoint(nodePosition))  
    209.         {  
    210.             //获取触摸点, 设置为终点  
    211.             PathSearchInfo::m_endX = _sp->m_x;  
    212.             PathSearchInfo::m_endY = _sp->m_y;  
    213.             //计算路径  
    214.             calculatePath();  
    215.             //绘制路径  
    216.             drawPath(  );  
    217.             playerMove();  
    218.               
    219.         }  
    220.           
    221.     }  
    222.     return true;  
    223. }  
    224.   
    225. void HelloWorld::onTouchMoved(Touch* touch, Event* event)  
    226. {  
    227.     // If it weren't for the TouchDispatcher, you would need to keep a reference  
    228.     // to the touch from touchBegan and check that the current touch is the same  
    229.     // as that one.  
    230.     // Actually, it would be even more complicated since in the Cocos dispatcher  
    231.     // you get Sets instead of 1 UITouch, so you'd need to loop through the set  
    232.     // in each touchXXX method.  
    233.       
    234. }  
    235. void HelloWorld::onTouchEnded(Touch* touch, Event* event)  
    236. {  
    237.       
    238. }   
    239.   
    240.   
    241. void HelloWorld::menuCloseCallback(Ref* pSender)  
    242. {  
    243. #if (CC_TARGET_PLATFORM == CC_PLATFORM_WP8) || (CC_TARGET_PLATFORM == CC_PLATFORM_WINRT)  
    244.     MessageBox("You pressed the close button. Windows Store Apps do not implement a close button.","Alert");  
    245.     return;  
    246. #endif  
    247.       
    248.     Director::getInstance()->end();  
    249.       
    250. #if (CC_TARGET_PLATFORM == CC_PLATFORM_IOS)  
    251.     exit(0);  
    252. #endif  
    253. }  
    254.   
    255. void HelloWorld::clearPath()  
    256. {  
    257.     for (vector<PathSprite*>::iterator iter = m_mapList.begin(); iter !=  m_mapList.end(); iter++)  
    258.     {  
    259.         (*iter)->setColor(ccColor3B::WHITE);  
    260.         (*iter)->m_costToSource = 0;  
    261.         (*iter)->m_FValue = 0;  
    262.         (*iter)->m_parent = NULL;  
    263.         (*iter)->m_child = NULL;  
    264.     }  
    265.       
    266.     //把移除了障碍物的地图放入检测列表中  
    267.     PathSearchInfo::m_inspectList = m_mapList;  
    268.     PathSearchInfo::m_openList.clear();  
    269.     PathSearchInfo::m_pathList.clear();  
    270.   
    271.     PathSearchInfo::m_startX = m_player->m_x;  
    272.     PathSearchInfo::m_startY = m_player->m_y;  
    273.     m_player->stopAllActions();  
    274.   
    275.     m_playerMoveStep = 0;  
    276. }  
    277.   
    278. void HelloWorld::playerMove()  
    279. {  
    280.     m_playerMoveStep++;  
    281.       
    282.     if (m_playerMoveStep >= PathSearchInfo::m_pathList.size()) {  
    283.         return;  
    284.     }  
    285.       
    286.     m_player->m_x = PathSearchInfo::m_pathList[m_playerMoveStep]->m_x;  
    287.     m_player->m_y = PathSearchInfo::m_pathList[m_playerMoveStep]->m_y;  
    288.       
    289.     m_player->runAction(Sequence::create(MoveTo::create(0.2, PathSearchInfo::m_pathList[m_playerMoveStep]->getPosition()), CallFunc::create(this, SEL_CallFunc(&HelloWorld::playerMove)) , NULL));  
    290.       
    291. }  


    转载自http://blog.csdn.net/w18767104183/article/details/39650409

    展开全文
  • 关于DX顶点法线算法

    2019-09-25 12:57:01
    假定一个三角形由顶点p0,p1,p2构成,首先计算位于三角形平面内两个向量。 p1-p0=U; p2-p0=V. 然后进行叉积。 P=U*V=(Px,Py,Pz); Px=(Uy*Vz-Uz*Vy); Py=(Uz*Vx-Ux*Vz); Pz=(Ux*Vy-Ux*Vx); 最后进行normol化...

    一句话:先叉积再normal化。

    假定一个三角形由顶点p0,p1,p2构成,首先计算位于三角形平面内的两个向量。

    p1-p0=U;

    p2-p0=V.

    然后进行叉积。

    P=U*V=(Px,Py,Pz);

    Px=(Uy*Vz-Uz*Vy);

    Py=(Uz*Vx-Ux*Vz);

    Pz=(Ux*Vy-Ux*Vx);

    最后进行normol化=单位向量/向量的模;单位向量一般为1;

    即1/sqrt(Px*Px);1/sqrt(Py*Py);1/sqrt(Pz*Pz);

     allright.

     

    转载于:https://www.cnblogs.com/AXIA-zy/archive/2012/10/19/2731541.html

    展开全文
  • cocos2dxA星算法

    2017-06-16 16:12:00
    来在cocos2dx上编写。这是终于效果图: 红色地方是执行轨迹,黑色是禁止区域,接下来是代码,请结合那篇博文观看: 首先创建地板类,必需要有x和y,还有依据那篇博文h和g。这是h文件里代码: .....
  • cocos2dx 3.0 A星算法

    2014-05-26 21:13:17
    在cocos2dx 3.0下实现A星算法,加入iOS下可以直接使用,加入Android需要修改Android.mk
  • 基于cocos2dx的RPG简单实用算法之2 - 角色跟随移动
  • 利用DX12遮挡查询API,实现三维立方体之间遮挡剔除查询算法,同时,考虑到一些遮挡查询算法会利用CPU进行协同优化,故此在我们实现算法中,我们利用GPU进行查询,再将查询结果返回给CPU端,由CPU进行逻辑...
  • cocos2dx碰撞检测算法

    千次阅读 2016-09-12 15:37:29
    在Cocos2d-x 3.x版本添加了对3D物体支持后,3D物体碰撞检测方法也随之更新,其中一种最简单碰撞检测方法就是AABB碰撞检测。1.AABB包围盒在游戏中,为了简化物体之间碰撞检测运算,通常会对物体创建一个规则...
  • cocos 2dx 基于C++ 五子棋AI算法思想

    千次阅读 2015-10-31 17:37:05
    今天我想要分享一下我做五子棋AI思路。因为在做这个之前,我没有接触过任何像这种...我AI算法要求每一次落子之后都要去计算每一个空暇位置“分值”,简单说,我们需要一个存放棋子数组,表示是否存放了棋子
  • 最近自己写RPG,发现在角色对象运动上面还是可以运动到不少以前数学知识(经理各种纠结脑补),好久没有写博客了,趁热总结一下算法思路,免得自己过两天又忘了。
  • 基于cocos2dx的RPG简单实用算法之3 - 多角色跟随阵型移动
  • 有关游戏中A*寻路算法,这里实现是简单路径算法
  • 这是用于实参数优化定向交叉 (DX) Matlab 代码。 这可用于实数编码 GA 和其他合适进化优化算法。 请引用为:Das,AK,Pratihar,DK:定向交叉(DX)运算符,使用遗传算法进行实际参数优化。 应用智能(2018)...
  • cocos2dx之A星算法

    千次阅读 2014-01-13 23:30:14
    研究了几个小时,看了网上一些资料,感觉都写得不好,可能是我太笨了,我现在来讲解一下在cocos2dx如何利用A*算法自动寻找目标。 我是根据上下左右来进行搜索,通过不停地去比较F值来取得取得最小代价得到路径:...
  • cocos2dx A*寻路算法

    2014-11-27 15:11:12
    你是否在做一款游戏时候想创造一些怪兽或者游戏主角,让它们移动到特定位置,避开墙壁和障碍物呢?...在网上已经有很多篇关于A星寻路算法的文章,但是大部分都是提供给已经了解基本原理高级开发者。 本篇教程将
  • 关于A* 算法的思路和方法,我会在代码中加以描述。 计算过程: 1,创建节点类AStartNode (请允许我偷下懒,将节点继承自Object,以便使用封装好容器__Array,如果愿意,可以封装一个能存储非Object对象...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 930
精华内容 372
关键字:

dx的算法