Esempio n. 1
0
  @Override
  public void scoreSearchToNode(
      Score score, Direction d, IConstraintMap c, IAttributeMap<? extends IAttribute> scoreAttrs) {
    Attribute attr = (Attribute) scoreAttrs.findAttr(scorerAttrId);
    if (attr == null) {
      return; // If we do not have the scorer attr present in the search direction, we do not score
              // - it wasn't 'wanted'
    }
    IBooleanValue bAttr = (IBooleanValue) attr;
    IAttributeConstraint na = c.findAttr(otherAttrId);

    // If there is no Node Data then we only score null
    if (na == null) { // || !na.hasValue()) {
      score.addNull(this, d);
      return;
    }

    float result = 0.0f;

    if (na.isIncludesNotSpecified()) {
      if (isScoreNull()) {
        result = getScoreOnNull();
      }
    }
    assert (na instanceof BooleanConstraint);
    result = Math.max(result, calcScore((BooleanConstraint) na, bAttr));
    score.add(this, result, d);
  }
Esempio n. 2
0
  /** Implementation that avoids creating any objects. Directly inspects the byte array */
  @Override
  public void scoreItemToItem(
      Score score,
      Direction d,
      IAttributeMap<IAttribute> otherAttrs,
      IAttributeMap<IAttribute> scoreAttrs) {
    // We assume that both are CompactAttrMap
    ByteArray scoreBytes = ((CompactAttrMap<?>) scoreAttrs).getByteArray();
    ByteArray otherBytes = ((CompactAttrMap<?>) otherAttrs).getByteArray();

    int scoreIndex = CompactAttrCodec.findAttrInBuf(scoreBytes, scorerAttrId);
    if (scoreIndex == CompactAttrCodec.NOT_FOUND) {
      return; // If we do not have the scorer attr present in the search direction, we do not score
              // - it wasn't 'wanted'
    }

    int otherIndex = CompactAttrCodec.findAttrInBuf(otherBytes, otherAttrId);

    if (otherIndex == CompactAttrCodec.NOT_FOUND) {
      score.addNull(this, d);
      return;
    }

    score.add(this, calcScore(scoreBytes, scoreIndex, otherBytes, otherIndex), d);
  }
  /* (non-Javadoc)
   * @see likemynds.db.indextree.Scorer#score(com.wwm.db.core.whirlwind.internal.IAttribute, likemynds.db.indextree.NodeAttributeContainer)
   */
  public void score(Score score, Score.Direction d, IAttribute wantAttr, IConstraintMap c) {

    IAttributeConstraint na = c.findAttr(otherAttrId);

    if (na == null) {
      return;
    }
    if (na
        .isIncludesNotSpecified()) { // na.hasValue() && // FIXME: Double check the logic this is
                                     // sometimes !includesNotSpecified()
      score.add(this, 1.0f, d);
      return;
    }
    //		if (!na.hasValue()) {
    //			return;
    //		}

    assert (wantAttr.getAttrId() == scorerAttrId);
    // score against bounding box
    EcefVector want = (EcefVector) wantAttr;
    DimensionsRangeConstraint lbv = (DimensionsRangeConstraint) na;
    if (lbv != null) {
      // if location is in box, there could be an exact match, so return 1.0f
      if (lbv.consistent(want)) {
        score.add(this, 1.0f, d);
        return;
      }

      // Else score based on distance from closest point of box, to the centre of this
      // RangePreference
      float distance = lbv.getDistance(want); // dist from

      // Find out how far inside or outside the preferred range location is
      // 1 down to 0 is within range, and negative is outside
      float scoreFactor = 1f - (distance / range);

      // If preferClose is false, score any value within range as 1
      if (!preferClose && scoreFactor >= 0f) {
        scoreFactor = 1f;
      }

      float convertedScore = scoreMapper.getScore(scoreFactor);

      score.add(this, convertedScore, d);
      return;
    }
  }
Esempio n. 4
0
  @Override
  public void scoreNodeToSearch(
      Score score,
      Direction d,
      IAttributeMap<IAttributeConstraint> c,
      IAttributeMap<IAttribute> searchAttrs) {
    IAttributeConstraint na = c.findAttr(scorerAttrId);
    if (na == null) {
      return; // If we do not have the scorer attr present in the search direction, we do not score
              // - it wasn't 'wanted'
    }
    IAttributeConstraint bNa = na;
    IBooleanValue otherAttr = (IBooleanValue) searchAttrs.findAttr(otherAttrId);

    // If some nulls under this node then Score 1 so
    // as not to push this node down in score
    if (bNa.isIncludesNotSpecified()) {
      score.add(this, maxScore, d);
      return;
    }

    //        // This should never happen
    //        if (!bNa.hasValue()) {
    //            assert(false);
    //            return;
    //        }

    // If there is no Attr Data then we only score null
    if (otherAttr == null) {
      score.addNull(this, d);
      return;
    }

    float result = calcScore((BooleanConstraint) bNa, otherAttr);
    score.add(this, result, d);
  }
  public void score(
      Score score,
      Score.Direction d,
      IAttribute wantAttr,
      IAttributeMap<? extends IAttribute> c,
      IAttributeMap<? extends IAttribute> scoreAttrs) {
    assert (wantAttr.getAttrId() == scorerAttrId);

    if (wantAttr instanceof EcefVector) {
      // We must be scoring a search to an item or an Item to a search
      EcefVector want = (EcefVector) wantAttr;
      EcefVector location = (EcefVector) c.findAttr(otherAttrId);
      if (location != null) {

        float distance = location.distance(want); // actual distance in miles

        // Find out how far inside or outside the preferred range location is
        // 1 down to 0 is within range, and negative is outside
        float scoreFactor = 1f - (distance / range);

        // If preferClose is false, score any value within range as 1
        if (!preferClose && scoreFactor >= 0f) {
          scoreFactor = 1f;
        }

        float convertedScore = scoreMapper.getScore(scoreFactor);

        score.add(this, convertedScore, d);
        score.setScorerAttribute("Distance", distance);
      }
      return;
    } else {
      // scoring from a node to a search
      // Node attr is min/max of EcefVectors (x, y, z)
      // Attr is single point
      // Result is either: point is within possible ranges or not.
      // TODO: As 'preferCloser' is a function of the scorer, then can support both options.
      // 		If false, scoreFactor is either 1.0 or 0.0 within the range.
      // 			Outside of the range, something better is possible, based on the
      // 			largest value of 'range' within the node, and the closest point.
      // 		If true, ...
      // FIXME: Revise the above when brain is functioning, and then correct what is below.
      //		  Currently it may actually be correct!!

      DimensionsRangeConstraint node =
          (DimensionsRangeConstraint) wantAttr; // min/man of a 3D (x,y,z) want
      EcefVector location = (EcefVector) scoreAttrs.findAttr(otherAttrId);
      if (location == null) {
        return; // No matching attribute, so no scoring to do
      }

      float scoreFactor;
      Dimensions low = new Dimensions(node.getMin());

      Dimensions hi = new Dimensions(node.getMax());

      DimensionsRangeConstraint box = new DimensionsRangeConstraint(0, low, hi);
      if (box.consistent(location)) {
        // location is within range of x,y,z's of want
        scoreFactor = 1.0f;
      } else {
        // see if it is within range of closest point of box

        float distance = box.getDistance(location); // dist from
        // Find out how far inside or outside the preferred range location is
        // 1 down to 0 is within range, and negative is outside
        scoreFactor = 1f - (distance / range);
      }

      // If preferClose is false, score any value within range as 1
      if (!preferClose && scoreFactor >= 0f) {
        scoreFactor = 1f;
      }

      float convertedScore = scoreMapper.getScore(scoreFactor);
      score.add(this, convertedScore, d);
    }
  }