צורות

בחירת פלטפורמה: Android iOS JavaScript

מפה עם קו פוליגון אדום מלא

ב-Google Maps API ל-Android יש כמה דרכים פשוטות להוספת צורות למפות שלך כדי להתאים אותן אישית עבור האפליקציה שלך.

  • Polyline הוא סדרה של קטעי קו מחוברים שיכולים יוצרות כל צורה שרוצים, ואפשר להשתמש בה כדי לסמן נתיבים ומסלולים במפה.
  • Polygon הוא צורה סגורה שאפשר להשתמש בה כדי לסמן אזורים במפה.
  • Circle הוא הקרנה גיאוגרפית מדויקת של מעגל על פני כדור הארץ שמצויר במפה.

עבור כל הצורות האלה, תוכלו להתאים אישית את המראה שלהן על ידי שינוי מספר המאפיינים.

דוגמאות קוד

המדריך בנושא הוספה פוליגונים וקווים פוליגוניים לייצוג שטחים ומסלולים כולל את כל הקוד לאפליקציה פשוטה ל-Android.

בנוסף, המאגר ApiDemos ב-GitHub כולל דוגמאות שממחישות את השימוש בצורות ואת התכונות שלהן:

  • CircleDemoActivity‏ (Java / Kotlin): מעגל
  • PolygonDemoActivity (Java / Kotlin): פוליגון
  • PolylineDemoActivity‏ (Java / Kotlin): קו פוליגוני

קווים פוליגונים

המחלקה Polyline מגדירה קבוצה של קו מחובר פלחים במפה. אובייקט Polyline מורכב מקבוצה של מיקומים LatLng, ויוצר סדרה של קטעי קו שמחברים את המיקומים האלה ברצף מסודר.

בסרטון הזה מוסבר איך לעזור למשתמשים להגיע ליעדם באמצעות קווים פוליגונים שאפשר לשרטט במפה.

כדי ליצור קו מרובע, קודם יוצרים אובייקט PolylineOptions ומוסיפים לו נקודות. נקודות מייצגות נקודה על פני כדור הארץ, והן באות לידי ביטוי כאובייקט LatLng. קטעי הקו נמתחים בין הנקודות לפי הסדר שבו מוסיפים אותם לאובייקט PolylineOptions.

כדי להוסיף נקודות לאובייקט PolylineOptions, קוראים לפונקציה PolylineOptions.add(). שימו לב שהשיטה הזו לוקחת מספר משתנה של פרמטרים, כדי שתוכלו הוספת מספר נקודות בכל פעם (אפשר גם להתקשר למספר PolylineOptions.addAll(Iterable<LatLng>)) אם הנקודות כבר מופיעות ברשימה).

עכשיו אפשר להוסיף את הקו הפוליגוני למפה באמצעות קריאה GoogleMap.addPolyline(PolylineOptions) הפונקציה מחזירה אובייקט Polyline שבאמצעותו אפשר לשנות את הקו הפוליגוני מאוחר יותר.

קטע הקוד הבא ממחיש איך להוסיף מלבן למפה:

Kotlin



// Instantiates a new Polyline object and adds points to define a rectangle
val polylineOptions = PolylineOptions()
    .add(LatLng(37.35, -122.0))
    .add(LatLng(37.45, -122.0)) // North of the previous point, but at the same longitude
    .add(LatLng(37.45, -122.2)) // Same latitude, and 30km to the west
    .add(LatLng(37.35, -122.2)) // Same longitude, and 16km to the south
    .add(LatLng(37.35, -122.0)) // Closes the polyline.

// Get back the mutable Polyline
val polyline = map.addPolyline(polylineOptions)

Java


// Instantiates a new Polyline object and adds points to define a rectangle
PolylineOptions polylineOptions = new PolylineOptions()
    .add(new LatLng(37.35, -122.0))
    .add(new LatLng(37.45, -122.0))  // North of the previous point, but at the same longitude
    .add(new LatLng(37.45, -122.2))  // Same latitude, and 30km to the west
    .add(new LatLng(37.35, -122.2))  // Same longitude, and 16km to the south
    .add(new LatLng(37.35, -122.0)); // Closes the polyline.

// Get back the mutable Polyline
Polyline polyline = map.addPolyline(polylineOptions);

המלבן מופיע במפה כמו בדוגמה הבאה:

מפה עם קו פוליגוני של מלבן

כדי לשנות את הצורה של הקו הפוליגוני לאחר הוספתו, אפשר לקרוא Polyline.setPoints() ומספקים רשימה חדשה של נקודות לקו הפוליגוני.

אפשר להתאים אישית את המראה של הקו הפוליגוני לפני שמוסיפים אותו למפה ואחרי שהוא נוסף למפה. פרטים נוספים זמינים בקטע התאמה אישית של המראה בהמשך.

התאמה אישית של קו פוליגוני

יש כמה דרכים להתאים אישית את המראה של קווים פוליגונליים:

  • קווים פוליגוניים בצבעים שונים מגדירים צבעים שונים לקטעי הקווים הפוליגוניים.
  • קווים פוליגונים עם שינוי הדרגתי צובעים קו פוליגון באמצעות שינוי הדרגתי של שני צבעים.
  • קווים פוליגוניים מוטמעים בסגנון פוליגונים באמצעות מפות סיביות חוזרות.

כדי להשתמש בהתאמות אישיות של קווים פוליגונים, צריך להשתמש ב-SDK של מפות ל-Android בגרסה 18.1.0 ואילך, ולהשתמש במעבד הגרפיקה העדכני ביותר של SDK של מפות ל-Android.

יצירת קו פוליגוני צבעוני

מפה עם קו פוליגוני צבעוני

אפשר להשתמש ב-spans כדי לצבוע פלחים ספציפיים של קו פוליגון. לשם כך, יוצרים אובייקטים מסוג StyleSpan ומוסיפים אותם ל-PolylineOptions באמצעות השיטות addSpan() או addSpans(). כברירת מחדל, כל פריט במערך יקבע את הצבע של קטע הקו המתאים. בדוגמה הבאה מוצג פלח של ההגדרה צבעים כדי ליצור קו פוליגוני עם מקטעי אדום וירוק:

Kotlin



val line = map.addPolyline(
    PolylineOptions()
        .add(LatLng(47.6677146, -122.3470447), LatLng(47.6442757, -122.2814693))
        .addSpan(StyleSpan(Color.RED))
        .addSpan(StyleSpan(Color.GREEN))
)

Java


Polyline line = map.addPolyline(new PolylineOptions()
        .add(new LatLng(47.6677146,-122.3470447), new LatLng(47.6442757,-122.2814693))
        .addSpan(new StyleSpan(Color.RED))
        .addSpan(new StyleSpan(Color.GREEN)));

יצירת קו פוליגוני הדרגתי

מפה עם קו פוליגון בגוון מדורג

ניתן להגדיר הדרגתי על ידי ציון שני 32 סיביות אלפא-אדום-ירוק-כחול (ARGB) מספרים שלמים, כדי לציין את צבעי ההתחלה והסיום של הקו. מגדירים את המאפיין הזה באובייקט האפשרויות של הצורה באמצעות קריאה ל-PolylineOptions.addSpan(). בדוגמה הבאה מוצגת יצירת קו פוליגון עם שיפוע מאדום לצהוב מגן החיות וודלנד פארק ל-Kirkland,‏ WA.

Kotlin



val line = map.addPolyline(
    PolylineOptions()
        .add(LatLng(47.6677146, -122.3470447), LatLng(47.6442757, -122.2814693))
        .addSpan(
            StyleSpan(
                StrokeStyle.gradientBuilder(
                    Color.RED,
                    Color.YELLOW
                ).build()
            )
        )
)

Java


Polyline line = map.addPolyline(new PolylineOptions()
        .add(new LatLng(47.6677146,-122.3470447), new LatLng(47.6442757,-122.2814693))
        .addSpan(new StyleSpan(StrokeStyle.gradientBuilder(Color.RED, Color.YELLOW).build())));

יצירת קו פוליגוני עם חותמת

מפה עם קו פוליגוני עם חותמת

אפשר להגדיר את המראה של קו מרובע כטקסטורת ביפ-מפט חוזרת. כדי לעשות זאת, יוצרים StampStyle של TextureStyle ומגדירים את המאפיין הזה באובייקט האפשרויות של הצורה באמצעות קריאה ל-PolylineOptions.addSpan(), כפי שמוצג כאן:

Kotlin



val stampStyle =
    TextureStyle.newBuilder(BitmapDescriptorFactory.fromResource(R.drawable.walking_dot)).build()
val span = StyleSpan(StrokeStyle.colorBuilder(Color.RED).stamp(stampStyle).build())
map.addPolyline(
    PolylineOptions()
        .add(LatLng(47.6677146, -122.3470447), LatLng(47.6442757, -122.2814693))
        .addSpan(span)
)

Java


StampStyle stampStyle =
        TextureStyle.newBuilder(BitmapDescriptorFactory.fromResource(R.drawable.walking_dot)).build();
StyleSpan span = new StyleSpan(StrokeStyle.colorBuilder(Color.RED).stamp(stampStyle).build());
map.addPolyline(new PolylineOptions()
        .add(new LatLng(47.6677146,-122.3470447), new LatLng(47.6442757,-122.2814693))
        .addSpan(span));

אירועים של קו פוליגוני

כברירת מחדל, אי אפשר ללחוץ על קווים פוליגונליים. אפשר להפעיל או להשבית את האפשרות ללחוץ על הקישור באמצעות קריאה לפונקציה Polyline.setClickable(boolean).

משתמשים ב-OnPolylineClickListener כדי להאזין לאירועי קליקים על קו פוליגון שניתן ללחוץ עליו. כדי להגדיר את הבורר הזה במפה, צריך להפעיל את הפונקציה GoogleMap.setOnPolylineClickListener(OnPolylineClickListener). כשמשתמש לוחץ על קו פוליגון, תקבלו קריאה חוזרת (callback) מסוג onPolylineClick(Polyline).

פוליגונים

Polygon אובייקטים דומים ל-Polyline כי הם מכילים סדרה של קואורדינטות ברצף. עם זאת, במקום להיות פתוחים, פוליגונים מיועדים להגדיר אזורים בתוך לולאה סגורה שהחלק הפנימי שלה מלא.

אפשר להוסיף Polygon למפה באותו אופן שבו מוסיפים Polyline. קודם כול יוצרים אובייקט PolygonOptions ולהוסיף לו כמה נקודות. הנקודות האלה יהוו את קווי המתאר של הפוליגון. לאחר מכן מוסיפים את הפוליגון למפה באמצעות קריאה ל-GoogleMap.addPolygon(PolygonOptions), שמחזירה אובייקט Polygon.

קטע הקוד הבא מוסיף מלבן למפה.

Kotlin



// Instantiates a new Polygon object and adds points to define a rectangle
val rectOptions = PolygonOptions()
    .add(
        LatLng(37.35, -122.0),
        LatLng(37.45, -122.0),
        LatLng(37.45, -122.2),
        LatLng(37.35, -122.2),
        LatLng(37.35, -122.0)
    )

// Get back the mutable Polygon
val polygon = map.addPolygon(rectOptions)

Java


// Instantiates a new Polygon object and adds points to define a rectangle
PolygonOptions polygonOptions = new PolygonOptions()
    .add(new LatLng(37.35, -122.0),
        new LatLng(37.45, -122.0),
        new LatLng(37.45, -122.2),
        new LatLng(37.35, -122.2),
        new LatLng(37.35, -122.0));

// Get back the mutable Polygon
Polygon polygon = map.addPolygon(polygonOptions);

כדי לשנות את הצורה של הפוליגון אחרי שהוא נוסף, אפשר לבצע קריאה ל-Polygon.setPoints() ולספק רשימה חדשה של נקודות לקו המתאר של הפוליגון.

אפשר להתאים אישית את המראה של הפוליגון גם לפני שמוסיפים אותו למפה וגם אחרי שמוסיפים אותו למפה. פרטים נוספים זמינים בקטע התאמה אישית של המראה בהמשך.

השלמה אוטומטית בפוליגון

הפוליגון בדוגמה שלמעלה מורכב מחמש קואורדינטות, אבל חשוב לשים לב שהקואורדינטות הראשונה והאחרונה הן באותו מיקום, והן מגדירות את הלולאה. עם זאת, בפועל, מאחר שמרובעים מגדירים אזורים סגורים, אין צורך להגדיר את הקואורדינטה האחרונה הזו. אם הקואורדינטה האחרונה שונה מהראשונה, ה-API 'יסגור' את הפוליגון באופן אוטומטי על ידי צירוף הקואורדינטה הראשונה בסוף רצף הקואורדינטות.

שני הפוליגונים הבאים זהים, והפעלת polygon.getPoints() לכל אחד מהם תחזיר את כל 4 הנקודות.

Kotlin



val polygon1 = map.addPolygon(
    PolygonOptions()
        .add(
            LatLng(0.0, 0.0),
            LatLng(0.0, 5.0),
            LatLng(3.0, 5.0),
            LatLng(0.0, 0.0)
        )
        .strokeColor(Color.RED)
        .fillColor(Color.BLUE)
)
val polygon2 = map.addPolygon(
    PolygonOptions()
        .add(
            LatLng(0.0, 0.0),
            LatLng(0.0, 5.0),
            LatLng(3.0, 5.0)
        )
        .strokeColor(Color.RED)
        .fillColor(Color.BLUE)
)

Java


Polygon polygon1 = map.addPolygon(new PolygonOptions()
    .add(new LatLng(0, 0),
        new LatLng(0, 5),
        new LatLng(3, 5),
        new LatLng(0, 0))
    .strokeColor(Color.RED)
    .fillColor(Color.BLUE));

Polygon polygon2 = map.addPolygon(new PolygonOptions()
    .add(new LatLng(0, 0),
        new LatLng(0, 5),
        new LatLng(3, 5))
    .strokeColor(Color.RED)
    .fillColor(Color.BLUE));

יצירת פוליגון חלול

אפשר לשלב כמה נתיבים באובייקט Polygon אחד כדי ליצור צורות מורכבות, כמו טבעות מלאות או "עוגות שוקולד" (שבהן אזורים פוליגונליים מופיעים בתוך הפוליגון כ"איים"). צורות מורכבות הן תמיד יצירתיות של כמה נתיבים פשוטים יותר.

יש להגדיר שני נתיבים באותו אזור. האזור הגדול מבין השניים מגדיר את אזור המילוי, והוא פוליגון פשוט ללא אפשרויות נוספות. לאחר מכן, מעבירים נתיב שני ל-method addHole(). כשהנתיב השני, הקטן יותר, מוקף לגמרי על ידי הנתיב הגדול יותר, נראה כאילו חלק מהפוליגון הוסר. אם החור חוצה את קווי המצולע, הפוליגון יוצג ללא מילוי.

קטע הקוד הבא יוצר מלבן אחד עם חור מלבני קטן יותר.

Kotlin



val hole = listOf(
    LatLng(1.0, 1.0),
    LatLng(1.0, 2.0),
    LatLng(2.0, 2.0),
    LatLng(2.0, 1.0),
    LatLng(1.0, 1.0)
)
val hollowPolygon = map.addPolygon(
    PolygonOptions()
        .add(
            LatLng(0.0, 0.0),
            LatLng(0.0, 5.0),
            LatLng(3.0, 5.0),
            LatLng(3.0, 0.0),
            LatLng(0.0, 0.0)
        )
        .addHole(hole)
        .fillColor(Color.BLUE)
)

Java


List<LatLng> hole = Arrays.asList(new LatLng(1, 1),
    new LatLng(1, 2),
    new LatLng(2, 2),
    new LatLng(2, 1),
    new LatLng(1, 1));
Polygon hollowPolygon = map.addPolygon(new PolygonOptions()
    .add(new LatLng(0, 0),
        new LatLng(0, 5),
        new LatLng(3, 5),
        new LatLng(3, 0),
        new LatLng(0, 0))
    .addHole(hole)
    .fillColor(Color.BLUE));

הפוליגון הריק מופיע במפה כמו בדוגמה הבאה:

מפה עם קו פתוח בצורת מלבן

אירועי פוליגון

כברירת מחדל, לא ניתן ללחוץ על פוליגונים. אפשר להפעיל או להשבית את האפשרות ללחוץ עליו באמצעות קריאה ל-Polygon.setClickable(boolean).

שימוש ב-OnPolygonClickListener כדי להקשיב לאירועים בפוליגון שניתן ללחוץ עליו. כדי להגדיר את ה-listener הזה במפה: קוראים לפונקציה GoogleMap.setOnPolygonClickListener(OnPolygonClickListener). כשמשתמש לוחץ על פוליגון, תקבלו קריאה חוזרת מסוג onPolygonClick(Polygon).

מעגלים

מפה עם מעגל

בנוסף לכיתה הגנרית Polygon, ממשק Maps API כולל גם כיתות ספציפיות לאובייקטים מסוג Circle, כדי לפשט את היצירה שלהם.

כדי ליצור מעגל, צריך לציין את שני המאפיינים הבאים:

  • center כ-LatLng.
  • radius במטרים.

לאחר מכן מגדירים מעגל בתור קבוצת כל הנקודות על פני כדור הארץ שנמצאים במרחק של radius מטרים מרמת center הנתונה. בזכות היטל Mercator שבו נעשה שימוש על ידי API של מפות Google יוצר כדור על פני משטח ישר, עיגול כמעט מושלם במפה כשהוא ממוקם ליד קו המשווה, והוא ייראה יותר ויותר לא מעגלי (על המסך) העיגול מתרחק מקו המשווה.

כדי לשנות את הצורה של העיגול אחרי הוספת העיגול, אפשר להתקשר Circle.setRadius() או Circle.setCenter() ומספקים ערכים חדשים.

אפשר להתאים אישית את המראה של העיגול גם לפני שמוסיפים אותו למפה וגם אחרי שמוסיפים אותו למפה. צפייה בקטע שעוסק ב- כדי לקבל פרטים נוספים, תוכלו להתאים אישית את המראה בהמשך.

קטע הקוד הבא מוסיף עיגול למפה על ידי בניית אובייקט CircleOptions והתקשרות GoogleMap.addCircle(CircleOptions):

Kotlin



// Instantiates a new CircleOptions object and defines the center and radius
val circleOptions = CircleOptions()
    .center(LatLng(37.4, -122.1))
    .radius(1000.0) // In meters

// Get back the mutable Circle
val circle = map.addCircle(circleOptions)

Java


// Instantiates a new CircleOptions object and defines the center and radius
CircleOptions circleOptions = new CircleOptions()
    .center(new LatLng(37.4, -122.1))
    .radius(1000); // In meters

// Get back the mutable Circle
Circle circle = map.addCircle(circleOptions);

אירועים של מעגלים

כברירת מחדל, אי אפשר ללחוץ על עיגולים. אפשר להפעיל ולהשבית את קליקביליות על ידי התקשרות אל GoogleMap.addCircle() באמצעות CircleOptions.clickable(boolean), או בטלפון Circle.setClickable(boolean).

שימוש ב-OnCircleClickListener כדי להקשיב לאירועים לוחצים על מעגל קליקבילי. כדי להגדיר את הבורר הזה במפה, צריך להפעיל את הפונקציה GoogleMap.setOnCircleClickListener(OnCircleClickListener).

כאשר משתמש לוחץ על מעגל, תקבל קריאה חוזרת של onCircleClick(Circle), כפי שמוצג בדוגמת הקוד הבאה:

Kotlin



val circle = map.addCircle(
    CircleOptions()
        .center(LatLng(37.4, -122.1))
        .radius(1000.0)
        .strokeWidth(10f)
        .strokeColor(Color.GREEN)
        .fillColor(Color.argb(128, 255, 0, 0))
        .clickable(true)
)
map.setOnCircleClickListener {
    // Flip the r, g and b components of the circle's stroke color.
    val strokeColor = it.strokeColor xor 0x00ffffff
    it.strokeColor = strokeColor
}

Java


Circle circle = map.addCircle(new CircleOptions()
    .center(new LatLng(37.4, -122.1))
    .radius(1000)
    .strokeWidth(10)
    .strokeColor(Color.GREEN)
    .fillColor(Color.argb(128, 255, 0, 0))
    .clickable(true));

map.setOnCircleClickListener(new GoogleMap.OnCircleClickListener() {
    @Override
    public void onCircleClick(Circle circle) {
        // Flip the r, g and b components of the circle's stroke color.
        int strokeColor = circle.getStrokeColor() ^ 0x00ffffff;
        circle.setStrokeColor(strokeColor);
    }
});

התאמה אישית של תצוגות

אפשר לשנות את המראה של צורה לפני שהוא נוסף למפה (על ידי ציון הנכס הרצוי באובייקט האפשרויות) או לאחר שהוא נוסף למפה. המנצחים הם נחשפות גם בכל הנכסים, כך שאפשר לגשת בקלות במצב של הצורה.

קטע הקוד הבא מוסיף קו פוליגוני כחול ועבה עם פלחים גיאודזיים מתוך מלבורן לפרת'. הקטעים הבאים יסבירו את המאפיינים האלה מפורט.

Kotlin



val polyline = map.addPolyline(
    PolylineOptions()
        .add(LatLng(-37.81319, 144.96298), LatLng(-31.95285, 115.85734))
        .width(25f)
        .color(Color.BLUE)
        .geodesic(true)
)

Java


Polyline polyline = map.addPolyline(new PolylineOptions()
    .add(new LatLng(-37.81319, 144.96298), new LatLng(-31.95285, 115.85734))
    .width(25)
    .color(Color.BLUE)
    .geodesic(true));

המפה תיראה כך:

מפה עם קו פוליגון ממלבורן לפרת&#39;

הערה: אפשר להחיל את רוב המאפיינים האלה על כל אחד מהצורות המתוארות, אבל יכול להיות שחלק מהמאפיינים לא יתאימו לצורות מסוימות (לדוגמה, לקו פוליגון לא יכול להיות צבע מילוי כי אין לו פנים).

צבע משיכה

צבע הקו הוא מספר שלם בצבע אלפא-אדום-ירוק-כחול (ARGB) של 32 סיביות, שמציין את את האטימות והצבע של קו הצורה. הגדרת המאפיין הזה אובייקט אפשרויות באמצעות קריאה ל-*Options.strokeColor() (או PolylineOptions.color() במקרה של קו פוליגוני). אם לא צוין, צבע הקו שמוגדר כברירת מחדל הוא שחור (Color.BLACK).

לאחר הוספת הצורה למפה, ניתן לגשת לצבע הקו באמצעות קריאה אל getStrokeColor() (או getColor() לקו פוליגוני), ויכול להיות שיש לשנות אותו התקשרות אל setStrokeColor() (setColor() for a polyline).

צבע מילוי

צבע המילוי רלוונטי רק לפוליגונים ולעיגולים. הוא לא חל על קווים פוליגונליים כי אין להם שטחים פנימיים מוגדרים. בפוליגון, האזורים החורים שלו אינם חלק מהחלק הפנימי של המצולע, אם הוגדר צבע מילוי.

צבע המילוי הוא מספר שלם של 32 ביט בפורמט אלפא-אדום-ירוק-כחול (ARGB), שמציין את השקיפות ואת הצבע של החלק הפנימי של הצורה. הגדרת הנכס הזה לאובייקט של האפשרויות של הצורה באמצעות קריאה ל-*Options.fillColor(). אם לא צוין, צבע הקו שמוגדר כברירת מחדל הוא שקוף (Color.TRANSPARENT).

אחרי שמוסיפים את הצורה למפה, אפשר לגשת לצבע המילוי באמצעות קריאה ל-getFillColor() ולשנות אותו באמצעות קריאה ל-setFillColor().

רוחב משיכה

רוחב קו המתאר, כערך צף בפיקסלים (px). רוחב הקו לא משתנה כשמשנים את מרחק התצוגה במפה (כלומר, לכל הצורות יהיה אותו רוחב קו בכל רמות מרחק התצוגה). מגדירים את המאפיין הזה באובייקט האפשרויות של הצורה באמצעות קריאה ל-*Options.strokeWidth() (או ל-PolylineOptions.width() עבור קו מרובע). אם לא צוין ערך, ערך ברירת המחדל של רוחב הקו הוא 10 פיקסלים.

לאחר הוספת הצורה למפה, ניתן לגשת לרוחב הקו באמצעות קריאה אל getStrokeWidth() (או getWidth() לקו פוליגוני), ויכול להיות שיש לשנות אותו התקשרות אל setStrokeWidth() (setWidth() for a polyline).

קו ביטול נעילה

ברירת המחדל של דפוס הקו היא קו מלא עבור קווים פוליגונים ועיגולים. ניתן לציין דפוס קווים מותאם אישית של PatternItem, כאשר כל פריט הוא מקף, נקודה או פער.

הדוגמה הבאה מגדירה את הדפוס של קו פוליגוני רצף של נקודה, ואחריו פער באורך 20 פיקסלים, קו מפריד באורך 30 פיקסלים ופער נוסף של 20 פיקסלים.

Kotlin



val pattern = listOf(
    Dot(), Gap(20F), Dash(30F), Gap(20F)
)
polyline.pattern = pattern

Java


List<PatternItem> pattern = Arrays.asList(
    new Dot(), new Gap(20), new Dash(30), new Gap(20));
polyline.setPattern(pattern);

הדפוס חוזר על עצמו לאורך הקו, החל מפריט הדפוס הראשון בנקודה הקודקודית הראשונה שצוינה לצורה.

סוגי המפרקים

לקווים פוליגוניים ולקווי מתאר של מצולעים, ניתן לציין שיפוע או עגול JointType כדי להחליף את סוג החיבור הקבוע שמוגדר כברירת מחדל.

בדוגמה הבאה חל סוג צומת עגול על קו פוליגון:

Kotlin



polyline.jointType = JointType.ROUND

Java


polyline.setJointType(JointType.ROUND);

סוג החיבור משפיע על הכיפופים הפנימיים בקו. אם יש קו חוצה כולל מקפים, סוג החיבור רלוונטי גם כאשר קו מפריד מכשיר משותף. סוגי המפרקים לא משפיעים על נקודות, מכיוון שהן תמיד מעגליות.

אותיות רישיות

אפשר לציין סגנון Cap לכל קצה של קו פוליגון. האפשרויות הן עגולות (ברירת מחדל), ריבוע, עגול או מפת סיביות מותאמת אישית. מגדירים את הסגנון ב-PolylineOptions.startCap וב-PolylineOptions.endCap, או משתמשים בשיטות ה-getter וה-setter המתאימות.

קטע הקוד הבא מציין מכסה עגולה בתחילת קו פוליגוני.

Kotlin



polyline.startCap = RoundCap()

Java


polyline.setStartCap(new RoundCap());

קטע הקוד הבא מציין מפת סיביות מותאמת אישית עבור מודעת הסיום:

Kotlin



polyline.endCap = CustomCap(BitmapDescriptorFactory.fromResource(R.drawable.arrow), 16F)

Java


polyline.setEndCap(
    new CustomCap(BitmapDescriptorFactory.fromResource(R.drawable.arrow), 16));

כשמשתמשים במפת סיביות מותאמת אישית, צריך לציין רוחב קווים בהתייחסות פיקסלים. ה-API יתאים את התצוגה של קובץ ה-bitmap בהתאם. רוחב הקו של ההפניה הוא רוחב הקו שבו השתמשתם בתכנון קובץ האימג' של התמונה בפורמט bitmap לכובע, במימדים המקוריים של התמונה. ברירת המחדל של רוחב קו הרוחב להפניה היא 10. פיקסלים. טיפ: כדי לקבוע את רוחב הקו של ההפניה, פותחים את קובץ ה-bitmap בהגדלת 100% בכלי לעריכת תמונות ומציבים את רוחב הקו הרצוי ביחס לתמונה.

אם משתמשים BitmapDescriptorFactory.fromResource() כדי ליצור את מפת הסיביות, צריך להשתמש במשאב שלא תלוי בדחיסות (nodpi).

קטעי נתיב גיאודזיים

ההגדרה הגאודזית חלה רק על קווים פוליגוניים ופוליגונים. לא רלוונטי למעגלים כי הם לא מוגדרים כאוסף של פלחים.

ההגדרה הגאודזית קובעת את האופן שבו מקטעי הקו בין עוקבים הקודקודים של הפוליגון/פוליגון משורטטים. קטעים גיאודזיים הם קטעים שמתארכים את הנתיב הקצר ביותר על פני כדור הארץ (ספירה), ולרוב הם מופיעים כקווים מעוקלים במפה עם הקרנה של Mercator. לא גיאוגרפי קטעים משורטטים כקווים ישרים במפה.

כדי להגדיר את המאפיין הזה באובייקט האפשרות של הצורה, קוראים *Options.geodesic() כאשר true מציין את הקטעים שיש לצייר עליהם גיאודסיקה ו-false מציינים את הקטעים שיש לשרטט כקווים ישרים. אם לא צוין, ברירת המחדל היא קטעים לא גיאודזיים (false).

לאחר הוספת הצורה למפה, ניתן לגשת להגדרה הגיאודסית באמצעות חיוג אל isGeodesic(), וייתכן שיתבצע שינוי בהתקשרות אל setGeodesic().

Z-index

הערך של z-index מציין את סדר העריכה של הצורה הזו ביחס לשכבות-על אחרות (צורות אחרות, שכבות-על של שטח וסכימות של משבצות) במפה. שכבת-על עם אינדקס z גבוה מצוירת מעל שכבות-על עם מדדי z נמוכים יותר. שני שכבות-על עם אותו ערך z-index מצוירות בסדר שרירותי.

חשוב לזכור שהסמנים תמיד מוצגים מעל שכבות-על אחרות, ללא קשר למספר השכבה של השכבות האלה.

כדי להגדיר את המאפיין הזה באובייקט האפשרויות של הצורה, שולחים קריאה ל-*Options.zIndex(). אם לא צוין, ערך ברירת המחדל של z-index הוא 0. אחרי הוספת הצורה אל במפה, ניתן לגשת ל-z-index דרך מתקשר אל getZIndex() וייתכן שהוא ישתנה באמצעות חיוג אל setZIndex().

חשיפה

הערך של השדה הזה מציין אם צריך לצייר את הצורה במפה. הערך true מציין שצריך לצייר אותה, והערך false מציין שלא צריך. היא מאפשרת להסתיר צורות במפה באופן זמני. כדי להסיר לצמיתות צורה מהמפה, צריך להפעיל את הפונקציה remove() על הצורה הזו.

כדי להגדיר את המאפיין הזה באובייקט האפשרויות של הצורה, צריך להפעיל את הפונקציה *Options.visible(). אם לא צוין, ברירת המחדל של הרשאות הגישה היא true. לאחר הוספת הצורה למפה, ניתן לגשת אליהם על ידי מתקשר אל isVisible() וייתכן שהוא ישתנה באמצעות חיוג אל setVisible().

שיוך נתונים לצורה

אפשר לאחסן אובייקט נתונים שרירותי עם קו מרובע, פוליגון או עיגול באמצעות השיטה setTag() של הצורה, ולאחזר את האובייקט באמצעות getTag(). לדוגמה, קוראים ל-Polyline.setTag() כדי לאחסן אובייקט נתונים עם קו פוליגון, וקוראים ל-Polyline.getTag() כדי לאחזר את אובייקט הנתונים.

הקוד הבא מגדיר תג שרירותי (A) לקו הפוליגון שצוין:

Kotlin



val polyline = map.addPolyline(
    PolylineOptions()
        .clickable(true)
        .add(
            LatLng(-35.016, 143.321),
            LatLng(-34.747, 145.592),
            LatLng(-34.364, 147.891),
            LatLng(-33.501, 150.217),
            LatLng(-32.306, 149.248),
            LatLng(-32.491, 147.309)
        )
)
polyline.tag = "A"

Java


Polyline polyline = map.addPolyline((new PolylineOptions())
    .clickable(true)
    .add(new LatLng(-35.016, 143.321),
        new LatLng(-34.747, 145.592),
        new LatLng(-34.364, 147.891),
        new LatLng(-33.501, 150.217),
        new LatLng(-32.306, 149.248),
        new LatLng(-32.491, 147.309)));

polyline.setTag("A");

הנה כמה דוגמאות לתרחישים שבהם כדאי לאחסן ולאחזר נתונים עם צורות:

  • יכול להיות שהאפליקציה שלכם תומכת בסוגים שונים של צורות, ואתם רוצים לטפל בהן בצורה שונה כשהמשתמש לוחץ עליהן.
  • יכול להיות שאתם עובדים עם מערכת שיש לה מזהים ייחודיים של רשומות, שבהם הצורות מייצגות רשומות ספציפיות במערכת הזו.
  • נתוני הצורה עשויים לציין עדיפות לקביעת מדד ה-z עבור .