areaviewer.java

传感器网络操作系统contiki。 被广泛应用于环境检测、结构健康监测等等。包括路由协议

                      currentChannelModel.addRectObstacle(
                          realStartX, 
                          realStartY, 
                          realWidth,
                          realHeight, 
                          false
                      );
                    }
                  }
                  // Check if the dialog has been cancelled
                  if (pm.isCanceled()) return;
                  
                  // Update progress
                  pm.setProgress(x);
                  pm.setNote("After/Before merging: " + 
                      currentChannelModel.getNumberOfObstacles() + 
                      "/" +
                      foundObstacles);
                }
                currentChannelModel.notifySettingsChanged();
                
                thisPlugin.repaint();
                
              } catch (Exception ex) {
                if (pm.isCanceled()) return;
                logger.fatal("Obstacle adding aborted..: ");
                ex.printStackTrace();
                pm.close();
              }
              pm.close();
            } 
          };
          
          // Start thread
          Thread thread = new Thread(runnable);
          thread.start();
        }
      }
    }
  };
    
  /**
   * Listens to settings changes in the radio medium.
   */
  private Observer radioMediumSettingsObserver = new Observer() {
    public void update(Observable obs, Object obj) {
      // Clear selected radio (if any selected) and radio medium coverage
      selectedRadio = null;
      channelImage = null;
      canvas.repaint();
    }
  };
  
  /**
   * Listens to settings changes in the radio medium.
   */
  private Observer radioMediumActivityObserver = new Observer() {
    public void update(Observable obs, Object obj) {
      // Just remove any selected radio (it may have been removed)
      canvas.repaint();
    }
  };
  
  /**
   * Listens to settings changes in the channel model.
   */
  private Observer channelModelSettingsObserver = new Observer() {
    public void update(Observable obs, Object obj) {
      needToRepaintObstacleImage = true;
      canvas.repaint();
    }
  };
  
  /**
   * Returns a color corresponding to given value where higher values are more green, and lower values are more red.
   * 
   * @param value Signal strength of received signal (dB)
   * @param lowBorder
   * @param highBorder
   * @return Integer containing standard ARGB color.
   */
  private int getColorOfSignalStrength(double value, double lowBorder, double highBorder) {
    double upperLimit = highBorder; // Best signal adds green
    double lowerLimit = lowBorder; // Bad signal adds red
    double intervalSize = (upperLimit - lowerLimit) / 2;
    double middleValue = lowerLimit + (upperLimit - lowerLimit) / 2;
    
    if (value > highBorder) {
      return 0xCC00FF00;
    }

    if (value < lowerLimit) {
      return 0xCCFF0000;
    }
    
    int red = 0, green = 0, blue = 0, alpha = 0xCC;
    
    // Upper limit (green)
    if (value > upperLimit - intervalSize) {
      green = (int) (255 - 255*(upperLimit - value)/intervalSize);
    }

    // Medium signal adds blue
    if (value > middleValue - intervalSize && value < middleValue + intervalSize) {
      blue = (int) (255 - 255*Math.abs(middleValue - value)/intervalSize);
    }

    // Bad signal adds red
    if (value < lowerLimit + intervalSize) {
      red = (int) (255 - 255*(value - lowerLimit)/intervalSize);
    }

    return (alpha << 24) | (red << 16) | (green << 8) | blue;
  }
  
  /**
   * Helps user adjust and calculate the channel propagation formula
   */
  private ActionListener formulaHandler = new ActionListener() {
    public void actionPerformed(ActionEvent e) {
      if (e.getActionCommand().equals("recalculate visible area")) {

        // Get resolution of new image
        final Dimension resolution = new Dimension(
            resolutionSlider.getValue(),
            resolutionSlider.getValue()
        );

        // Abort if no radio selected
        if (selectedRadio == null) {
          channelImage = null;
          canvas.repaint();
          return;
        }

        // Get new location/size of area to attenuate 
        final double startX = -currentPanX;
        final double startY = -currentPanY;
        final double width = canvas.getWidth() / currentZoomX;
        final double height = canvas.getHeight() / currentZoomY;

        // Get sending radio position
        Position radioPosition = currentRadioMedium.getRadioPosition(selectedRadio);
        final double radioX = radioPosition.getXCoordinate();
        final double radioY = radioPosition.getYCoordinate();

        // Create temporary image
        final BufferedImage tempChannelImage = new BufferedImage(resolution.width, resolution.height, BufferedImage.TYPE_INT_ARGB);
        
        // Save time for later analysis
        final long timeBeforeCalculating = System.currentTimeMillis();
        
        // Create progress monitor
        final ProgressMonitor pm = new ProgressMonitor(
            GUI.frame,
            "Calculating channel attenuation",
            null,
            0,
            resolution.width - 1
        );
        
        // Thread that will perform the work
        final Runnable runnable = new Runnable() { 
          public void run() { 
            try {

              // Available signal strength intervals
              double lowestImageValue = Double.MAX_VALUE;
              double highestImageValue = -Double.MAX_VALUE;
              
              // Create image values (calculate each pixel)
              double[][] imageValues = new double[resolution.width][resolution.height];
              for (int x=0; x < resolution.width; x++) {
                for (int y=0; y < resolution.height; y++) {

                  if (dataTypeToVisualize == ChannelModel.TransmissionData.SIGNAL_STRENGTH) {
                    // Attenuate
                    double[] signalStrength = currentChannelModel.getReceivedSignalStrength(
                        radioX,
                        radioY,
                        startX + width * x/(double) resolution.width,
                        startY + height * y/(double) resolution.height
                    );
                    
                    // Collecting signal strengths
                    if (signalStrength[0] < lowestImageValue)
                      lowestImageValue = signalStrength[0];
                    if (signalStrength[0] > highestImageValue)
                      highestImageValue = signalStrength[0];
                    
                    imageValues[x][y] = signalStrength[0];
                    
                  } else if (dataTypeToVisualize == ChannelModel.TransmissionData.SIGNAL_STRENGTH_VAR) {
                    // Attenuate
                    double[] signalStrength = currentChannelModel.getReceivedSignalStrength(
                        radioX,
                        radioY,
                        startX + width * x/(double) resolution.width,
                        startY + height * y/(double) resolution.height
                    );
                    
                    // Collecting variances
                    if (signalStrength[1] < lowestImageValue)
                      lowestImageValue = signalStrength[1];
                    if (signalStrength[1] > highestImageValue)
                      highestImageValue = signalStrength[1];
                    
                    imageValues[x][y] = signalStrength[1];
                    
                  } else if (dataTypeToVisualize == ChannelModel.TransmissionData.SNR) {
                    // Get signal to noise ratio
                    double[] snr = currentChannelModel.getSINR(
                        radioX,
                        radioY,
                        startX + width * x/(double) resolution.width,
                        startY + height * y/(double) resolution.height,
                        -Double.MAX_VALUE
                    );
                    
                    // Collecting signal to noise ratio
                    if (snr[0] < lowestImageValue)
                      lowestImageValue = snr[0];
                    if (snr[0] > highestImageValue)
                      highestImageValue = snr[0];
                    
                    imageValues[x][y] = snr[0];

                  } else if (dataTypeToVisualize == ChannelModel.TransmissionData.SNR_VAR) {
                    // Get signal to noise ratio
                    double[] snr = currentChannelModel.getSINR(
                        radioX,
                        radioY,
                        startX + width * x/(double) resolution.width,
                        startY + height * y/(double) resolution.height,
                        -Double.MAX_VALUE
                    );
                    
                    // Collecting variances
                    if (snr[1] < lowestImageValue)
                      lowestImageValue = snr[1];
                    if (snr[1] > highestImageValue)
                      highestImageValue = snr[1];
                    
                    imageValues[x][y] = snr[1];
                  } else if (dataTypeToVisualize == ChannelModel.TransmissionData.PROB_OF_RECEPTION) {
                    // Get probability of receiving a packet TODO What size? Does it matter?
                    double probability = currentChannelModel.getProbability(
                        radioX,
                        radioY,
                        startX + width * x/(double) resolution.width,
                        startY + height * y/(double) resolution.height,
                        -Double.MAX_VALUE
                    )[0];
                    
                    // Collecting variances
                    if (probability < lowestImageValue)
                      lowestImageValue = probability;
                    if (probability > highestImageValue)
                      highestImageValue = probability;
                    
                    imageValues[x][y] = probability;
                  } else if (dataTypeToVisualize == ChannelModel.TransmissionData.DELAY_SPREAD_RMS) {
                    // Get RMS delay spread of receiving a packet
                    double rmsDelaySpread = currentChannelModel.getRMSDelaySpread(
                        radioX,
                        radioY,
                        startX + width * x/(double) resolution.width,
                        startY + height * y/(double) resolution.height
                    );
                    
                    // Collecting variances
                    if (rmsDelaySpread < lowestImageValue)
                      lowestImageValue = rmsDelaySpread;
                    if (rmsDelaySpread > highestImageValue)
                      highestImageValue = rmsDelaySpread;
                    
                    imageValues[x][y] = rmsDelaySpread;
                  }
                  
                  // Check if the dialog has been cancelled
                  if (pm.isCanceled()) return;
                  
                  // Update progress
                  pm.setProgress(x);
                  
                }
              }

              // Adjust coloring signal strength limit
              if (coloringIsFixed) {
                if (dataTypeToVisualize == ChannelModel.TransmissionData.SIGNAL_STRENGTH) {
                  lowestImageValue = -100;
                  highestImageValue = 0;
                } else if (dataTypeToVisualize == ChannelModel.TransmissionData.SIGNAL_STRENGTH_VAR) {
                  lowestImageValue = 0;
                  highestImageValue = 20;
                } else if (dataTypeToVisualize == ChannelModel.TransmissionData.SNR) {
                  lowestImageValue = -10;
                  highestImageValue = 30;
                } else if (dataTypeToVisualize == ChannelModel.TransmissionData.SNR_VAR) {
                  lowestImageValue = 0;
                  highestImageValue = 20;
                } else if (dataTypeToVisualize == ChannelModel.TransmissionData.PROB_OF_RECEPTION) {
                  lowestImageValue = 0;
                  highestImageValue = 1;
                } else if (dataTypeToVisualize == ChannelModel.TransmissionData.DELAY_SPREAD_RMS) {
                  lowestImageValue = 0;
                  highestImageValue = 5;
                }
              }
              
              // Save coloring high-low interval
              coloringHighest = highestImageValue;
              coloringLowest = lowestImageValue;
              
              // Create image
              for (int x=0; x < resolution.width; x++) {
                for (int y=0; y < resolution.height; y++) {
                  
                  tempChannelImage.setRGB(
                      x, 
                      y, 
                      getColorOfSignalStrength(imageValues[x][y], lowestImageValue, highestImageValue)
                  );
                }
              }
              logger.info("Attenuating area done, time=" + (System.currentTimeMillis() - timeBeforeCalculating));
              
              // Repaint to show the new channel propagation