ROBOT LOCALIZATION AND MOTION PLANNING

4 次查看（过去 30 天）

Ken 2016-12-2

0
链接

此问题的直接链接

https://ww2.mathworks.cn/matlabcentral/answers/315127-robot-localization-and-motion-planning

评论： Ken 2017-1-20

The state of the robot is fully described by its position and orientation xk=[xk,yk,ϕk]T , expressed in the global coordinate frame marked with x and y . Given a control input uk=[rk,Δϕk]T , the robots first turns on the spot by an angle Δϕk and then moves in a straight line for a distance of rk in the direction it is facing.

Please implement the motion model as an anonymous function assigned to f that models this behaviour. This motion model will be employed to arrive at a prior estimate x^ k of the robot pose given a posterior estimate of the pose at a previous time instance xk−1 and control inputs uk as x^k=f(xk−1,uk). (x^k is estimate of xk). Please also provide the Jacobians with respect to the state xk−1 and the input uk as anonymous functions and assign them to Fx and Fu respectively.

1 f = @(x, u) ????;

2 Fx = @(x,u) ????;

3 Fu = @(x,u) ????;

3 个评论
显示 1更早的评论隐藏 1更早的评论

Ken 2016-12-2

编辑：Ken 2016-12-2

Thanks Walter.
It is to find the Jacobian Fx, Fu of f w.r.t. x and u. I tried this but get error "Undefined function 'x' for input arguments of type 'double' :
f = @(x, u) [x(1)+u(1)*cos(x(3)+u(2));
x(2)+u(1)*sin(x(3)+u(2)) ; x(3)+u(2)];
Fx = @(x,u) 1;1;1;
Fu = @(x,u) cos(x(2)+1);sin(x(2)+1);1;

Ken 2016-12-2

编辑：Walter Roberson 2016-12-2

在 MATLAB Online 中打开

Some added info:

x = [1.; 2. ; pi/4]
u = [.1; pi/8]

请先登录，再进行评论。

请先登录，再回答此问题。

采纳的回答

Walter Roberson 2017-1-16

0
链接

此回答的直接链接

https://ww2.mathworks.cn/matlabcentral/answers/315127-robot-localization-and-motion-planning#answer_250817

test http://www.mathworks.com/matlabcentral/answers/315127-robot-localization-and-motion-planning#comment_419758

7 个评论
显示 5更早的评论隐藏 5更早的评论

Ken 2017-1-17

编辑：Walter Roberson 2017-1-18

在 MATLAB Online 中打开

Thanks Walter. First attempt:

function BF(G, Start, Goal)
   Queue = Queue_init_FIFO();
   Closed = Queue_init_FIFO();
Cost = Queue_init_FIFO()
     Queue = Queue_push_FIFO(Queue, Start);
     while ~Queue_isempty_FIFO(Queue)
       [curr, Queue] = Queue_pop_FIFO(Queue)
       if isequal(curr, Goal)
         return
       end
%1. is curr =-1 i.e. an obstacle?
If curr ~= -1
continue
end
%closed = Queue_push_FIFO(Closed, curr);
       next = Graph_expand(G, curr);
       for K = 1 : size(next, 1)
         this_next = next(K,:);
         if ~ Closed_ismember_FIFO(Closed, next)
           Queue = Queue_push_FIFO(Queue, this_next);
end
%The eligible cells to expand are in Queue, choose the least costly cells %i.e. cells closest to Start
NextSolutionMap(x,y) = min((SolutionMap(x-1,y) – Start(1)+ SolutionMap(x-1,y)…
 – Start(2)),  (SolutionMap(x+1,y) – Start(1) + SolutionMap(x+1,y) – Start(2)),  ...
(SolutionMap(x,y-1) – Start(1) + SolutionMap(x,y-1) – Start(2)),…
(SolutionMap(x,y+1) – Start(1) + SolutionMap(x,y+1) – Start(2));
  Cost = Cost_push_FIFO(Cost,[x,y]);  
SolutionMap(x,y) = Cost(x,y) %problem asks for g i.e. cost values to be stored here
end
        end  
      
Made assumptions:

1. No need of closed - if there is obstacle i.e. -1, we don't expand that cell. The prob of using a cell again after expanded is not there as it would not be minimum.

2. Confused about Next, nextsolution

Ken 2017-1-18

在 MATLAB Online 中打开

Thanks Walter.

Feel I am out of my league here so am trying a simpler problem i.e. to find the shortest path from start to goal using the same cost i.e. 1 for vert edge, 1 for horiz edge. Tried this but stuck at Min - goes into an endless loop. Please help.

Map = zeros(11,9);
Map(1,:) = -1; Map(11,:) = -1; Map(:,1) = -1; Map(:,9)     = -1;
Map(9,2) = -1; Map(10,2) = -1; Map(10,3)= -1; Map(5:6,5:8) = -1;
Start = [3,7];
Goal  = [9,6];
SolutionMap = Inf*ones(size(Map)); %store g-values in here.
G = Map;
%function BF(G, Start, Goal) 
Queue = Queue_init_FIFO(); 
Closed = Queue_init_FIFO(); 
Cost = Queue_init_FIFO() 
Queue = Queue_push_FIFO(Queue, Start); 
Closed = Closed_push_FIFO(Queue, Start); 
while ~Queue_isempty_FIFO(Queue) 
[curr, Queue] = Queue_pop_FIFO(Queue); 
if isequal(curr, Goal) 
return 
end 
1. is curr =-1 i.e. an obstacle? 
for curr ~= -1 
continue 
if ~ Closed_ismember_FIFO(Closed, next)
    next = curr;
    next=Start;
    while next ~= Goal
        if next ~=-1
    x=next(1);
    y=next(2);
end
Queue = Queue_push_FIFO(Queue, this_next); 
NextSolutionMap(x,y) = min((SolutionMap(x-1,y) - Goal (1)+ SolutionMap(x-1,y)- Goal(2)),...
(SolutionMap(x+1,y)- Goal(1) + SolutionMap(x+1,y)- Goal(2)),... 
(SolutionMap(x,y-1) - Goal(1) + SolutionMap(x,y-1) - Goal(2)),...
(SolutionMap(x,y+1) - Goal(1) + SolutionMap(x,y+1) - Goal(2)));
next=NextSolutionMap(x,y);
%Cost = Cost_push_FIFO(Cost,[x,y]); 
%SolutionMap(x,y) = Cost(x,y) %problem asks for g i.e. cost values to be stored here 
end 
    end

Ken 2017-1-20

Walter, Maybe I tested your patience but please help!!

请先登录，再进行评论。

更多回答（1 个）

Walter Roberson 2016-12-2

0
链接

此回答的直接链接

https://ww2.mathworks.cn/matlabcentral/answers/315127-robot-localization-and-motion-planning#answer_245760

在 MATLAB Online 中打开

Assuming your formulae are correct,

Fx = @(x,u) [1;1;1];
Fu = @(x,u) [cos(x(2)+1);sin(x(2)+1);1];

115 个评论
显示 113更早的评论隐藏 113更早的评论

Walter Roberson 2016-12-15

在 MATLAB Online 中打开

What you are already doing could be called a Breadth-First Search, under the understanding that you are pruning the search at each step. But it could also be called a Depth-First Search with the same understanding.

More typically, Breadth-First Searches require some form of queuing. At any step, you have a list of nodes to be examined (the first step initialized this list to the starting node), and you run through all of those nodes finding all of the possible next steps, queuing those next steps into a list. So step #1 finds all the nodes 1 step away from the origin, step #2 finds all of the nodes 2 steps away from the origin, and so on. At each step, the number of nodes "deep" in the path is the same for all candidates.

With a Breath-First Search, you would not talk about "back-tracking". However, you do need to consider the termination conditions: you can stop on the first step in which the target is reached (taking the least expensive out of all the routes found with that many steps), but the route that has the least number of steps will not necessarily be the least expensive route. If you are looking for the least expensive route, then the search needs to continue until either you have exhausted all possible routes, or until you can prove that any further route would have to be more expensive than some known route.

A Depth-First search also requires some form of queuing. At any step you pick the least expensive of all of the queued routes that are "in focus", and you find the possible next steps from there and queue those, and shift focus to what you just queued. The queued nodes at any one time will have many different depths. At the point where you know that you cannot go any further (no more candidate nodes that are not already in the tree between the source and the current node) then you pop that focus and move back one step and take the next least expensive and focus on there. That would commonly be referred to as back-tracking.

You have to pay attention to the termination condition for Depth-First Search, too: you might have taken the least expensive route at each point, but that could have led you the long way around. Sometimes the least expensive overall route might involve going up the steepest hill, and that would not be the route that would be found first by Depth-First. For example, traveling between x and y on

   333
   x5y

the least expensive from x (with diagonals not allowed) would be up to the 3, then across to the second 3, then across to the third 3, then down to the y, for a path total of 9; in this case it is cheaper overall to take the more expensive 5 step.

The algorithm you were using originally has no queuing at all, and so can easily get stuck: it had no provision for saying "Oops, dead end! Let's go back a few steps and make a different decision!"

There is no trivial modification of the previous algorithm to make it Depth First or Breadth First: you have to design in the queuing (or "stack").

Ken 2016-12-16

编辑：Walter Roberson 2016-12-18

在 MATLAB Online 中打开

Thanks Walter. Tried this but get error "Index exceeds matrix dimensions":

% initialize search start and goal locations
SearchStart = [3,7];
SearchGoal  = [9,6];
CurrPos = SearchStart;
% iteratively solve for path from start to goal
      min = abs(-5);
      for x=3:1:size(SMap,1)
       for y=7:1:size(SMap,2)
               if and(SMap(x,y)~=0,SMap(x,y)~=-1)
                       
                  if min > abs(SearchGoal(1) - CurrPos(1)+ 1 + SearchGoal(2) - CurrPos(2));
                      min = abs(SearchGoal(1) - CurrPos(1)+ 1 + SearchGoal(2) - CurrPos(2));
                      min1=min
                      x=min1(1)+1;
                      y=min1(2)+1;
                  end
                      if min > abs(SearchGoal(1) - CurrPos(1) - 1 + SearchGoal(2) - CurrPos(2));
                          min = abs(SearchGoal(1) - CurrPos(1) - 1 + SearchGoal(2) - CurrPos(2));
                          min2=min
                          x=min2(1)+1;
                      y=min2(2)+1;
                      end
                      if min > abs(SearchGoal(1) - CurrPos(1) + SearchGoal(2) - CurrPos(2)+1);
                          min = abs(SearchGoal(1) - CurrPos(1) + SearchGoal(2) - CurrPos(2)+1);
                          min3=min
                          x=min3(1)+1;
                      y=min3(2)+1;
                      end
                       if min > abs(SearchGoal(1) - CurrPos(1) + SearchGoal(2) - CurrPos(2)-1);
                           min = abs(SearchGoal(1) - CurrPos(1) + SearchGoal(2) - CurrPos(2)-1);
                           min4=min
                           x=min4(1)+1;
                      y=min4(2)+1;
                       end                    
                  if SolutionMap(x,y) == 0
                  end
                  end            
               end     
             end

Ken 2016-12-21

编辑：Walter Roberson 2016-12-21

在 MATLAB Online 中打开

Thanks Walter. Your code works fine by itself but when I fit it into the algorithm, get errors:

 Map = zeros(11,9);
 Map(1,:) = -1; Map(11,:) -1; Map(:,1) = -1; Map(:,9)     = -1;
 Map(9,2) = -1; Map(10,2) = -1; Map(10,3)= -1; Map(5:6,5:8) = -1;
 SearchStart = [3,7];
 SearchGoal  = [9,6];
 CurrPos = SearchStart;
 SolutionMap = Inf*ones(size(Map)); %store g-values in here.
 x=3;y=7;
 nrow = size(SolutionMap,1);
ncol = size(SolutionMap,2);
 while ~isequal(SolutionMap(x,y),SearchGoal) 
 if SearchGoal(1) > CurrPos(1);x = x + 1; 
 end
 if SearchGoal(1) < CurrPos(1);x = x - 1;
 end
 if SearchGoal(2) > CurrPos(2);y = y + 1;
 end
 if SearchGoal(2) < CurrPos(2);y = y - 1;
 end
 idx = sub2ind([nrow, ncol], x, y);
 candidates = [];
 if x > 1; candidates = [candidates, idx - 1]; end;%(x-1,y)
[candidates, idx - 1];
 if x < nrow; candidates = [candidates, idx + 1]; end  %(x+1, y)
 [candidates, idx + 1];
 if y > 1; candidates = [candidates, idx - nrow]; end  %(x, y-1)
 [candidates, idx - nrow];
 if y < ncol; candidates = [candidates, idx + nrow]; end %(x, y+1)
 [candidates, idx + nrow];
 [least, whichleast] = min( SolutionMap(candidates) );
 [newx, newy] = ind2sub([nrow, ncol], candidates(whichleast));
 x = newx;
 y = newy;
 end

Ken 2016-12-21

编辑：Ken 2016-12-21

I did some mods since I posted my code, so here is the modified code:
Map = zeros(11,9);
Map(1,:) = -1; Map(11,:) -1; Map(:,1) = -1; Map(:,9) = -1;
Map(9,2) = -1; Map(10,2) = -1; Map(10,3)= -1; Map(5:6,5:8) = -1;
SearchStart = [3,7];
SearchGoal = [9,6];
CurrPos = SearchStart;
SolutionMap = Inf*ones(size(Map)); %store g-values in here.
x=3;y=7;
nrow = size(SolutionMap,1);
ncol = size(SolutionMap,2);
while ~isequal(SolutionMap(x,y),SearchGoal)
if SearchGoal(1) > CurrPos(1);x = x + 1;
end
if SearchGoal(1) < CurrPos(1);x = x - 1;
end
if SearchGoal(2) > CurrPos(2);y = y + 1;
end
if SearchGoal(2) < CurrPos(2);y = y - 1;
end
idx = sub2ind([nrow, ncol], x, y);
candidates = [];
if x > 1; candidates = [candidates, idx - 1]; end;%(x-1,y)
[candidates, idx - 1];
if x < nrow; candidates = [candidates, idx + 1]; end %(x+1, y)
[candidates, idx + 1];
if y > 1; candidates = [candidates, idx - nrow]; end %(x, y-1)
[candidates, idx - nrow];
if y < ncol; candidates = [candidates, idx + nrow]; end %(x, y+1)
[candidates, idx + nrow];
[least, whichleast] = min( SolutionMap(candidates) );
[newx, newy] = ind2sub([nrow, ncol], candidates(whichleast));
x = newx;
y = newy;
end
%[newx, newy]
% visualize the solution map (g values)
imagesc(SolutionMap)
set(gca,'dataAspectRatio',[1 1 1])

The error msg is pasted below:

Error using sub2ind (line 55) Out of range subscript.

Error in Untitled2 (line 25) idx = sub2ind([nrow, ncol], x, y);

Ken 2016-12-21

在 MATLAB Online 中打开

Thanks Walter. I deleted the 4 SearchGoal lines and now have just the lines for the question and the lines of code from you. What's missing is - once the least value is found (of the 4 cells surrounding the current cell) how to proceed towards SearchGoal from the current cell.

Map = zeros(11,9);
Map(1,:) = -1; Map(11,:) -1; Map(:,1) = -1; Map(:,9)     = -1;
Map(9,2) = -1; Map(10,2) = -1; Map(10,3)= -1; Map(5:6,5:8) = -1;
SearchStart = [3,7];
SearchGoal  = [9,6];
CurrPos = SearchStart;
SolutionMap = Inf*ones(size(Map)); %store g-values in here.
nrow = size(SolutionMap,1);
ncol = size(SolutionMap,2);
while ~isequal(SolutionMap(x,y),SearchGoal) 
idx = sub2ind([nrow, ncol], x, y);
candidates = [];
if x > 1; candidates = [candidates, idx - 1]; end;%(x-1,y)
[candidates, idx - 1];
if x < nrow; candidates = [candidates, idx + 1]; end  %(x+1, y)
[candidates, idx + 1];
if y > 1; candidates = [candidates, idx - nrow]; end  %(x, y-1)
[candidates, idx - nrow];
if y < ncol; candidates = [candidates, idx + nrow]; end %(x, y+1)
[candidates, idx + nrow];
[least, whichleast] = min( SolutionMap(candidates) );
[newx, newy] = ind2sub([nrow, ncol], candidates(whichleast));
x = newx;
y = newy;
end

Walter Roberson 2016-12-23

在 MATLAB Online 中打开

For breadth-first search, at each step you have to make a "hypothesis" that each of the possibilities is the right way to go, so you enter into a list the chain with each of the possible moves relative to where you are focusing on. When one of the chains gets stuck, remove it from the list. Keep going until either you have found one possibility or else until you have accounted for all possibilities. If you find one possibility then it will be a version with the minimum number of steps, but it will not necessarily be the least expensive route. If you cover all of the possibilities then you can pick the least expensive amount them.

For example,

while ~isempty(active_chains)
  new_chains = {};
  for K = 1 : length(active_chains)
    this_chain = active_chains{K};
    if this_chain ends at the goal then
      successful_chains{end+1} = this_chain;
    else
      find all steps that are immediately legal on this_chain,
      discarding any potential step that would go outside the
      matrix and discarding any potential step that would
      re-visit a location that is already present in this_chain.
      Any potential step you find,
         new_chains{end+1} = [this_chain, the next step]
     end
   end
   active_chains = new_chains;
 end

Eventually you will get to the point where there are no further steps possible in any chain and so new_chains will be empty and so active_chains will become empty. At that point, successful_chains will contain all of the possible routes. You can then figure out which of them is least expensive.

Ken 2016-12-24

编辑：Walter Roberson 2016-12-24

I am pasting the problem below just in case.

However, the algorithm selects the next cell and if that cell is not to be expanded (because it may be an obstacle or may have been previously expanded), it goes to the closed list not to be expanded.

In the obstacle map shown below black cells represent obstacles, whereas white cells are freely traversable. We define the map's origin at the top left corner, corresponding to cell (1,1). The first dimension faces downward, and the second dimension to the right. The robot and goal locations are marked by "R" and "G", respectively. Note that the map is assumed to have been inflated by the Robot's radius already. It thus represents the configuration space, and planning can proceed for a point-sized robot directly.

Please implement Breadth First search on the above map from the Robot's position R ("SearchStart") to G ("SearchGoal") and store the distance of each cell to "SearchStart" in the variable "SolutionMap". During expansion, use the 4-neighborhood (i.e., only move vertically and horizontally) and assign each edge a weight (cost of traversal) of "1".

Walter Roberson 2017-1-3

在 MATLAB Online 中打开

Use isempty() to test if something is empty.

Queue (end + 1) = value

that will work if value is a scalar, or if you initialized Queue as a cell array and value is a cell array. However, you have chosen the style of making the value into a coordinate pair. In order to be able to store a vector into a single location like Queue(end+1) then you need to be using cell arrays. You would then use

Queue{end+1} = value;

Your line

if Queue(n) = next

is not syntactically valid in MATLAB. MATLAB uses == for comparisons.

Remember that you have defined next to be a vector, but your Queue(n) is going to be either a scalar (if you define the queue to hold scalars) or a cell array.

And remember to read carefully:

https://www.mathworks.com/help/matlab/ref/if.html

"if expression, statements, end evaluates an expression, and executes a group of statements when the expression is true. An expression is true when its result is nonempty and contains only nonzero elements (logical or real numeric). Otherwise, the expression is false."

You need to be careful using if with vectors: when you are working with vectors you should seriously consider using any() or all(), even if only to re-assure the people reading your code that you knew exactly what you wanted to happen.

Ken 2017-1-6

编辑：Walter Roberson 2017-1-6

在 MATLAB Online 中打开

SolutionMap:

Code:

% initialize map, search start and goal as well as the solution map
Map = zeros(11,9);
Map(1,:) = -1; Map(11,:) =1; Map(:,1) = -1; Map(:,9)     = -1;
Map(9,2) = -1; Map(10,2) = -1; Map(10,3)= -1; Map(5:6,5:8) = -1;
SearchStart = [3,7];
SearchGoal  = [9,6];
CurrPos = SearchStart;
SolutionMap = Inf*ones(size(Map)); %store g-values in here.
nrow = size(SolutionMap,1);
ncol = size(SolutionMap,2);
function BF(G, Start, Goal)
Queue = Queue_init_FIFO();
   Closed = Queue_init_FIFO();
     Queue = Queue_push_FIFO(Queue, Start);
     while ~Queue_isempty_FIFO(Queue)
       [currPos, Queue] = Queue_pop_FIFO(Queue)
       if isequal(currPos, Goal)
         return
       end
       Closed = Queue_push_FIFO(Closed, currPos);
       next = Graph_expand(G, currPos);
       for K = 1 : size(next, 1)
         this_next = next(K,:);
         if ~Queue_ismember_FIFO(Closed, next)
           Queue = Queue_push_FIFO(Queue, this_next);
       end
     end
end
imagesc(SolutionMap)
set(gca,'dataAspectRatio',[1 1 1])
           end

Ken 2017-1-10

编辑：Ken 2017-1-11

在 MATLAB Online 中打开

Tried this (Breadth_First_Search) as the main program which calls FUNCTION BF which calls FUNCTION G_EXP. Get errors: Trial>> BF Not enough input arguments.

Error in BF (line 5) Queue = Queue_push_FIFO(Queue, Start);

Map = zeros(11,9);
Map(1,:) = -1; Map(11,:) =1; Map(:,1) = -1; Map(:,9)     = -1;
Map(9,2) = -1; Map(10,2) = -1; Map(10,3)= -1; Map(5:6,5:8) = -1;
Start = [3,7];
Goal  = [9,6];
CurrPos = Start;
%x = curr(1);
%y = curr(2);
SolutionMap = Inf*ones(size(Map)); %store g-values in here.
nrow = size(SolutionMap,1);
ncol = size(SolutionMap,2);
BF(SolutionMap, Start, Goal)

BF:

function BF(SolutionMap, Start, Goal)
   Queue = Queue_init_FIFO();
   Closed = Queue_init_FIFO();
     Queue = Queue_push_FIFO(Queue, Start);
     while ~Queue_isempty_FIFO(Queue)
       [curr, Queue] = Queue_pop_FIFO(Queue)
       if isequal(curr, Goal)
         return
       end
       Closed = Queue_push_FIFO(Closed, curr);
       next = G_EXP(SolutionMap, curr);
       for K = 1 : size(next, 1)
         this_next = next(K,:);
         if ~Queue_ismember_FIFO(Closed, next)
           Queue = Queue_push_FIFO(Queue, this_next);
         end
       end

G_EXP:

function next = G_EXP(SolutionMap, curr)
x = curr(1);
y = curr(2);
candidates = [];
if x > 1; candidates = [candidates, idx - 1]; return;end;%(x-1,y)
[candidates, idx - 1];
if x < nrow; candidates = [candidates, idx + 1]; return;end  %(x+1, y)
[candidates, idx + 1];
if y > 1; candidates = [candidates, idx - nrow]; return;end  %(x, y-1)
[candidates, idx - nrow];
if y < ncol; candidates = [candidates, idx + nrow]; return;end %(x, y+1)

Walter Roberson 2017-1-11

The algorithm you gave in http://www.mathworks.com/matlabcentral/answers/315127-robot-localization-and-motion-planning#comment_416044 has some flaws:

It does not check that the current node is eligible for expansion (the expand routine is not intended to do that in the algorithm). This would result in incorrect paths
the algorithm does not give any clue as to how to create the solution map
Potential nodes are checked for being closed at the time of expand(), but are not checked when they become current. Nodes can end up being closed after queuing if they become current and are found to be blocked; and whether or not they are found to be blocked, the algorithm defines that they get queued as closed when they become current. Because of this algorithm set-up, a node can end up queued twice. It is inefficient to expand the same node twice. The algorithm should either re-check for closed when a node becomes current or else it should avoid entering anything into the queue when it is already in the queue.

It could make sense to have a node in the queue multiple times if the step costs are variable, or if you were not using a breadth-first search, as the alternate entries could potentially represent a less-expensive route, but in the case of a breadth-first search with constant step cost, it is not possible that the other route might be less expensive.

To deal with the creation of the solution map, I found it effective to add a new queue for the costs. Initialize that queue with a 0. Each time you pop off something from Queue, also pop the current cost from the cost queue. Each time you add something onto the Queue, also queue (1 more than the current cost). When a location becomes current and is not a location that is blocked, then set the solution map at that location to be the current cost (that was popped off the cost queue.) At each point, the N'th element of the Queue and the N'th element of the cost queue are paired, representing the cost to reach that location.

Ken 2017-1-16

Thanks Walter. Looked at it - too complex for me!

Walter Roberson 2017-1-16

Break it into pieces. When I write

"It does not check that the current node is eligible for expansion (the expand routine is not intended to do that in the algorithm). This would result in incorrect paths"

then the obvious solution is that the code should check that the current node is eligible for expansion -- that it is not a blocked location (check within the graph!) and that it has not already been added to the Closed list.

请先登录，再进行评论。

请先登录，再回答此问题。